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       /* Call build_user_type_conversion again for the error.  */
4951       return build_user_type_conversion
4952         (totype, convs->u.expr, LOOKUP_NORMAL);
4953
4954     case ck_list:
4955       {
4956         /* Conversion to std::initializer_list<T>.  */
4957         tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0);
4958         tree new_ctor = build_constructor (init_list_type_node, NULL);
4959         unsigned len = CONSTRUCTOR_NELTS (expr);
4960         tree array, val;
4961         VEC(tree,gc) *parms;
4962         unsigned ix;
4963
4964         /* Convert all the elements.  */
4965         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val)
4966           {
4967             tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum,
4968                                           1, false, false, complain);
4969             if (sub == error_mark_node)
4970               return sub;
4971             check_narrowing (TREE_TYPE (sub), val);
4972             CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
4973           }
4974         /* Build up the array.  */
4975         elttype = cp_build_qualified_type
4976           (elttype, TYPE_QUALS (elttype) | TYPE_QUAL_CONST);
4977         array = build_array_of_n_type (elttype, len);
4978         array = finish_compound_literal (array, new_ctor);
4979
4980         parms = make_tree_vector ();
4981         VEC_safe_push (tree, gc, parms, decay_conversion (array));
4982         VEC_safe_push (tree, gc, parms, size_int (len));
4983         /* Call the private constructor.  */
4984         push_deferring_access_checks (dk_no_check);
4985         new_ctor = build_special_member_call
4986           (NULL_TREE, complete_ctor_identifier, &parms, totype, 0, complain);
4987         release_tree_vector (parms);
4988         pop_deferring_access_checks ();
4989         return build_cplus_new (totype, new_ctor);
4990       }
4991
4992     case ck_aggr:
4993       return get_target_expr (digest_init (totype, expr));
4994
4995     default:
4996       break;
4997     };
4998
4999   expr = convert_like_real (convs->u.next, expr, fn, argnum,
5000                             convs->kind == ck_ref_bind ? -1 : 1,
5001                             convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
5002                             c_cast_p,
5003                             complain);
5004   if (expr == error_mark_node)
5005     return error_mark_node;
5006
5007   switch (convs->kind)
5008     {
5009     case ck_rvalue:
5010       expr = decay_conversion (expr);
5011       if (! MAYBE_CLASS_TYPE_P (totype))
5012         return expr;
5013       /* Else fall through.  */
5014     case ck_base:
5015       if (convs->kind == ck_base && !convs->need_temporary_p)
5016         {
5017           /* We are going to bind a reference directly to a base-class
5018              subobject of EXPR.  */
5019           /* Build an expression for `*((base*) &expr)'.  */
5020           expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
5021           expr = convert_to_base (expr, build_pointer_type (totype),
5022                                   !c_cast_p, /*nonnull=*/true);
5023           expr = cp_build_indirect_ref (expr, RO_IMPLICIT_CONVERSION, complain);
5024           return expr;
5025         }
5026
5027       /* Copy-initialization where the cv-unqualified version of the source
5028          type is the same class as, or a derived class of, the class of the
5029          destination [is treated as direct-initialization].  [dcl.init] */
5030       flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
5031       if (convs->user_conv_p)
5032         /* This conversion is being done in the context of a user-defined
5033            conversion (i.e. the second step of copy-initialization), so
5034            don't allow any more.  */
5035         flags |= LOOKUP_NO_CONVERSION;
5036       expr = build_temp (expr, totype, flags, &diag_kind);
5037       if (diag_kind && fn)
5038         {
5039           if ((complain & tf_error))
5040             emit_diagnostic (diag_kind, input_location, 0,
5041                              "  initializing argument %P of %qD", argnum, fn);
5042           else if (diag_kind == DK_ERROR)
5043             return error_mark_node;
5044         }
5045       return build_cplus_new (totype, expr);
5046
5047     case ck_ref_bind:
5048       {
5049         tree ref_type = totype;
5050
5051         if (convs->bad_p && TYPE_REF_IS_RVALUE (ref_type)
5052             && real_lvalue_p (expr))
5053           {
5054             if (complain & tf_error)
5055               {
5056                 error ("cannot bind %qT lvalue to %qT",
5057                        TREE_TYPE (expr), totype);
5058                 if (fn)
5059                   error ("  initializing argument %P of %q+D", argnum, fn);
5060               }
5061             return error_mark_node;
5062           }
5063
5064         /* If necessary, create a temporary.
5065
5066            VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
5067            that need temporaries, even when their types are reference
5068            compatible with the type of reference being bound, so the
5069            upcoming call to cp_build_unary_op (ADDR_EXPR, expr, ...)
5070            doesn't fail.  */
5071         if (convs->need_temporary_p
5072             || TREE_CODE (expr) == CONSTRUCTOR
5073             || TREE_CODE (expr) == VA_ARG_EXPR)
5074           {
5075             tree type = convs->u.next->type;
5076             cp_lvalue_kind lvalue = real_lvalue_p (expr);
5077
5078             if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))
5079                 && !TYPE_REF_IS_RVALUE (ref_type))
5080               {
5081                 if (complain & tf_error)
5082                   {
5083                     /* If the reference is volatile or non-const, we
5084                        cannot create a temporary.  */
5085                     if (lvalue & clk_bitfield)
5086                       error ("cannot bind bitfield %qE to %qT",
5087                              expr, ref_type);
5088                     else if (lvalue & clk_packed)
5089                       error ("cannot bind packed field %qE to %qT",
5090                              expr, ref_type);
5091                     else
5092                       error ("cannot bind rvalue %qE to %qT", expr, ref_type);
5093                   }
5094                 return error_mark_node;
5095               }
5096             /* If the source is a packed field, and we must use a copy
5097                constructor, then building the target expr will require
5098                binding the field to the reference parameter to the
5099                copy constructor, and we'll end up with an infinite
5100                loop.  If we can use a bitwise copy, then we'll be
5101                OK.  */
5102             if ((lvalue & clk_packed)
5103                 && CLASS_TYPE_P (type)
5104                 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
5105               {
5106                 if (complain & tf_error)
5107                   error ("cannot bind packed field %qE to %qT",
5108                          expr, ref_type);
5109                 return error_mark_node;
5110               }
5111             if (lvalue & clk_bitfield)
5112               {
5113                 expr = convert_bitfield_to_declared_type (expr);
5114                 expr = fold_convert (type, expr);
5115               }
5116             expr = build_target_expr_with_type (expr, type);
5117           }
5118
5119         /* Take the address of the thing to which we will bind the
5120            reference.  */
5121         expr = cp_build_unary_op (ADDR_EXPR, expr, 1, complain);
5122         if (expr == error_mark_node)
5123           return error_mark_node;
5124
5125         /* Convert it to a pointer to the type referred to by the
5126            reference.  This will adjust the pointer if a derived to
5127            base conversion is being performed.  */
5128         expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
5129                            expr);
5130         /* Convert the pointer to the desired reference type.  */
5131         return build_nop (ref_type, expr);
5132       }
5133
5134     case ck_lvalue:
5135       return decay_conversion (expr);
5136
5137     case ck_qual:
5138       /* Warn about deprecated conversion if appropriate.  */
5139       string_conv_p (totype, expr, 1);
5140       break;
5141
5142     case ck_ptr:
5143       if (convs->base_p)
5144         expr = convert_to_base (expr, totype, !c_cast_p,
5145                                 /*nonnull=*/false);
5146       return build_nop (totype, expr);
5147
5148     case ck_pmem:
5149       return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
5150                              c_cast_p);
5151
5152     default:
5153       break;
5154     }
5155
5156   if (convs->check_narrowing)
5157     check_narrowing (totype, expr);
5158
5159   if (issue_conversion_warnings && (complain & tf_warning))
5160     expr = convert_and_check (totype, expr);
5161   else
5162     expr = convert (totype, expr);
5163
5164   return expr;
5165 }
5166
5167 /* ARG is being passed to a varargs function.  Perform any conversions
5168    required.  Return the converted value.  */
5169
5170 tree
5171 convert_arg_to_ellipsis (tree arg)
5172 {
5173   /* [expr.call]
5174
5175      The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5176      standard conversions are performed.  */
5177   arg = decay_conversion (arg);
5178   /* [expr.call]
5179
5180      If the argument has integral or enumeration type that is subject
5181      to the integral promotions (_conv.prom_), or a floating point
5182      type that is subject to the floating point promotion
5183      (_conv.fpprom_), the value of the argument is converted to the
5184      promoted type before the call.  */
5185   if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
5186       && (TYPE_PRECISION (TREE_TYPE (arg))
5187           < TYPE_PRECISION (double_type_node))
5188       && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (arg))))
5189     arg = convert_to_real (double_type_node, arg);
5190   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
5191     arg = perform_integral_promotions (arg);
5192
5193   arg = require_complete_type (arg);
5194
5195   if (arg != error_mark_node
5196       && (type_has_nontrivial_copy_init (TREE_TYPE (arg))
5197           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (arg))))
5198     {
5199       /* [expr.call] 5.2.2/7:
5200          Passing a potentially-evaluated argument of class type (Clause 9)
5201          with a non-trivial copy constructor or a non-trivial destructor
5202          with no corresponding parameter is conditionally-supported, with
5203          implementation-defined semantics.
5204
5205          We used to just warn here and do a bitwise copy, but now
5206          cp_expr_size will abort if we try to do that.
5207
5208          If the call appears in the context of a sizeof expression,
5209          it is not potentially-evaluated.  */
5210       if (cp_unevaluated_operand == 0)
5211         error ("cannot pass objects of non-trivially-copyable "
5212                "type %q#T through %<...%>", TREE_TYPE (arg));
5213     }
5214
5215   return arg;
5216 }
5217
5218 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused.  */
5219
5220 tree
5221 build_x_va_arg (tree expr, tree type)
5222 {
5223   if (processing_template_decl)
5224     return build_min (VA_ARG_EXPR, type, expr);
5225
5226   type = complete_type_or_else (type, NULL_TREE);
5227
5228   if (expr == error_mark_node || !type)
5229     return error_mark_node;
5230
5231   if (type_has_nontrivial_copy_init (type)
5232       || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5233       || TREE_CODE (type) == REFERENCE_TYPE)
5234     {
5235       /* Remove reference types so we don't ICE later on.  */
5236       tree type1 = non_reference (type);
5237       /* conditionally-supported behavior [expr.call] 5.2.2/7.  */
5238       error ("cannot receive objects of non-trivially-copyable type %q#T "
5239              "through %<...%>; ", type);
5240       expr = convert (build_pointer_type (type1), null_node);
5241       expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
5242       return expr;
5243     }
5244
5245   return build_va_arg (input_location, expr, type);
5246 }
5247
5248 /* TYPE has been given to va_arg.  Apply the default conversions which
5249    would have happened when passed via ellipsis.  Return the promoted
5250    type, or the passed type if there is no change.  */
5251
5252 tree
5253 cxx_type_promotes_to (tree type)
5254 {
5255   tree promote;
5256
5257   /* Perform the array-to-pointer and function-to-pointer
5258      conversions.  */
5259   type = type_decays_to (type);
5260
5261   promote = type_promotes_to (type);
5262   if (same_type_p (type, promote))
5263     promote = type;
5264
5265   return promote;
5266 }
5267
5268 /* ARG is a default argument expression being passed to a parameter of
5269    the indicated TYPE, which is a parameter to FN.  Do any required
5270    conversions.  Return the converted value.  */
5271
5272 static GTY(()) VEC(tree,gc) *default_arg_context;
5273
5274 tree
5275 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
5276 {
5277   int i;
5278   tree t;
5279
5280   /* If the ARG is an unparsed default argument expression, the
5281      conversion cannot be performed.  */
5282   if (TREE_CODE (arg) == DEFAULT_ARG)
5283     {
5284       error ("the default argument for parameter %d of %qD has "
5285              "not yet been parsed",
5286              parmnum, fn);
5287       return error_mark_node;
5288     }
5289
5290   /* Detect recursion.  */
5291   for (i = 0; VEC_iterate (tree, default_arg_context, i, t); ++i)
5292     if (t == fn)
5293       {
5294         error ("recursive evaluation of default argument for %q#D", fn);
5295         return error_mark_node;
5296       }
5297   VEC_safe_push (tree, gc, default_arg_context, fn);
5298
5299   if (fn && DECL_TEMPLATE_INFO (fn))
5300     arg = tsubst_default_argument (fn, type, arg);
5301
5302   /* Due to:
5303
5304        [dcl.fct.default]
5305
5306        The names in the expression are bound, and the semantic
5307        constraints are checked, at the point where the default
5308        expressions appears.
5309
5310      we must not perform access checks here.  */
5311   push_deferring_access_checks (dk_no_check);
5312   arg = break_out_target_exprs (arg);
5313   if (TREE_CODE (arg) == CONSTRUCTOR)
5314     {
5315       arg = digest_init (type, arg);
5316       arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5317                                         "default argument", fn, parmnum,
5318                                         tf_warning_or_error);
5319     }
5320   else
5321     {
5322       /* We must make a copy of ARG, in case subsequent processing
5323          alters any part of it.  For example, during gimplification a
5324          cast of the form (T) &X::f (where "f" is a member function)
5325          will lead to replacing the PTRMEM_CST for &X::f with a
5326          VAR_DECL.  We can avoid the copy for constants, since they
5327          are never modified in place.  */
5328       if (!CONSTANT_CLASS_P (arg))
5329         arg = unshare_expr (arg);
5330       arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5331                                         "default argument", fn, parmnum,
5332                                         tf_warning_or_error);
5333       arg = convert_for_arg_passing (type, arg);
5334     }
5335   pop_deferring_access_checks();
5336
5337   VEC_pop (tree, default_arg_context);
5338
5339   return arg;
5340 }
5341
5342 /* Returns the type which will really be used for passing an argument of
5343    type TYPE.  */
5344
5345 tree
5346 type_passed_as (tree type)
5347 {
5348   /* Pass classes with copy ctors by invisible reference.  */
5349   if (TREE_ADDRESSABLE (type))
5350     {
5351       type = build_reference_type (type);
5352       /* There are no other pointers to this temporary.  */
5353       type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
5354     }
5355   else if (targetm.calls.promote_prototypes (type)
5356            && INTEGRAL_TYPE_P (type)
5357            && COMPLETE_TYPE_P (type)
5358            && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5359                                    TYPE_SIZE (integer_type_node)))
5360     type = integer_type_node;
5361
5362   return type;
5363 }
5364
5365 /* Actually perform the appropriate conversion.  */
5366
5367 tree
5368 convert_for_arg_passing (tree type, tree val)
5369 {
5370   tree bitfield_type;
5371
5372   /* If VAL is a bitfield, then -- since it has already been converted
5373      to TYPE -- it cannot have a precision greater than TYPE.
5374
5375      If it has a smaller precision, we must widen it here.  For
5376      example, passing "int f:3;" to a function expecting an "int" will
5377      not result in any conversion before this point.
5378
5379      If the precision is the same we must not risk widening.  For
5380      example, the COMPONENT_REF for a 32-bit "long long" bitfield will
5381      often have type "int", even though the C++ type for the field is
5382      "long long".  If the value is being passed to a function
5383      expecting an "int", then no conversions will be required.  But,
5384      if we call convert_bitfield_to_declared_type, the bitfield will
5385      be converted to "long long".  */
5386   bitfield_type = is_bitfield_expr_with_lowered_type (val);
5387   if (bitfield_type
5388       && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
5389     val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
5390
5391   if (val == error_mark_node)
5392     ;
5393   /* Pass classes with copy ctors by invisible reference.  */
5394   else if (TREE_ADDRESSABLE (type))
5395     val = build1 (ADDR_EXPR, build_reference_type (type), val);
5396   else if (targetm.calls.promote_prototypes (type)
5397            && INTEGRAL_TYPE_P (type)
5398            && COMPLETE_TYPE_P (type)
5399            && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5400                                    TYPE_SIZE (integer_type_node)))
5401     val = perform_integral_promotions (val);
5402   if (warn_missing_format_attribute)
5403     {
5404       tree rhstype = TREE_TYPE (val);
5405       const enum tree_code coder = TREE_CODE (rhstype);
5406       const enum tree_code codel = TREE_CODE (type);
5407       if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
5408           && coder == codel
5409           && check_missing_format_attribute (type, rhstype))
5410         warning (OPT_Wmissing_format_attribute,
5411                  "argument of function call might be a candidate for a format attribute");
5412     }
5413   return val;
5414 }
5415
5416 /* Returns true iff FN is a function with magic varargs, i.e. ones for
5417    which no conversions at all should be done.  This is true for some
5418    builtins which don't act like normal functions.  */
5419
5420 static bool
5421 magic_varargs_p (tree fn)
5422 {
5423   if (DECL_BUILT_IN (fn))
5424     switch (DECL_FUNCTION_CODE (fn))
5425       {
5426       case BUILT_IN_CLASSIFY_TYPE:
5427       case BUILT_IN_CONSTANT_P:
5428       case BUILT_IN_NEXT_ARG:
5429       case BUILT_IN_VA_START:
5430         return true;
5431
5432       default:;
5433         return lookup_attribute ("type generic",
5434                                  TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
5435       }
5436
5437   return false;
5438 }
5439
5440 /* Subroutine of the various build_*_call functions.  Overload resolution
5441    has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
5442    ARGS is a TREE_LIST of the unconverted arguments to the call.  FLAGS is a
5443    bitmask of various LOOKUP_* flags which apply to the call itself.  */
5444
5445 static tree
5446 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
5447 {
5448   tree fn = cand->fn;
5449   const VEC(tree,gc) *args = cand->args;
5450   tree first_arg = cand->first_arg;
5451   conversion **convs = cand->convs;
5452   conversion *conv;
5453   tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
5454   int parmlen;
5455   tree val;
5456   int i = 0;
5457   int j = 0;
5458   unsigned int arg_index = 0;
5459   int is_method = 0;
5460   int nargs;
5461   tree *argarray;
5462   bool already_used = false;
5463
5464   /* In a template, there is no need to perform all of the work that
5465      is normally done.  We are only interested in the type of the call
5466      expression, i.e., the return type of the function.  Any semantic
5467      errors will be deferred until the template is instantiated.  */
5468   if (processing_template_decl)
5469     {
5470       tree expr;
5471       tree return_type;
5472       const tree *argarray;
5473       unsigned int nargs;
5474
5475       return_type = TREE_TYPE (TREE_TYPE (fn));
5476       nargs = VEC_length (tree, args);
5477       if (first_arg == NULL_TREE)
5478         argarray = VEC_address (tree, CONST_CAST (VEC(tree,gc) *, args));
5479       else
5480         {
5481           tree *alcarray;
5482           unsigned int ix;
5483           tree arg;
5484
5485           ++nargs;
5486           alcarray = XALLOCAVEC (tree, nargs);
5487           alcarray[0] = first_arg;
5488           for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
5489             alcarray[ix + 1] = arg;
5490           argarray = alcarray;
5491         }
5492       expr = build_call_array_loc (input_location,
5493                                    return_type, build_addr_func (fn), nargs,
5494                                    argarray);
5495       if (TREE_THIS_VOLATILE (fn) && cfun)
5496         current_function_returns_abnormally = 1;
5497       if (!VOID_TYPE_P (return_type))
5498         require_complete_type (return_type);
5499       return convert_from_reference (expr);
5500     }
5501
5502   /* Give any warnings we noticed during overload resolution.  */
5503   if (cand->warnings)
5504     {
5505       struct candidate_warning *w;
5506       for (w = cand->warnings; w; w = w->next)
5507         joust (cand, w->loser, 1);
5508     }
5509
5510   /* Make =delete work with SFINAE.  */
5511   if (DECL_DELETED_FN (fn) && !(complain & tf_error))
5512     return error_mark_node;
5513
5514   if (DECL_FUNCTION_MEMBER_P (fn))
5515     {
5516       /* If FN is a template function, two cases must be considered.
5517          For example:
5518
5519            struct A {
5520              protected:
5521                template <class T> void f();
5522            };
5523            template <class T> struct B {
5524              protected:
5525                void g();
5526            };
5527            struct C : A, B<int> {
5528              using A::f;        // #1
5529              using B<int>::g;   // #2
5530            };
5531
5532          In case #1 where `A::f' is a member template, DECL_ACCESS is
5533          recorded in the primary template but not in its specialization.
5534          We check access of FN using its primary template.
5535
5536          In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
5537          because it is a member of class template B, DECL_ACCESS is
5538          recorded in the specialization `B<int>::g'.  We cannot use its
5539          primary template because `B<T>::g' and `B<int>::g' may have
5540          different access.  */
5541       if (DECL_TEMPLATE_INFO (fn)
5542           && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
5543         perform_or_defer_access_check (cand->access_path,
5544                                        DECL_TI_TEMPLATE (fn), fn);
5545       else
5546         perform_or_defer_access_check (cand->access_path, fn, fn);
5547     }
5548
5549   /* Find maximum size of vector to hold converted arguments.  */
5550   parmlen = list_length (parm);
5551   nargs = VEC_length (tree, args) + (first_arg != NULL_TREE ? 1 : 0);
5552   if (parmlen > nargs)
5553     nargs = parmlen;
5554   argarray = (tree *) alloca (nargs * sizeof (tree));
5555
5556   /* The implicit parameters to a constructor are not considered by overload
5557      resolution, and must be of the proper type.  */
5558   if (DECL_CONSTRUCTOR_P (fn))
5559     {
5560       if (first_arg != NULL_TREE)
5561         {
5562           argarray[j++] = first_arg;
5563           first_arg = NULL_TREE;
5564         }
5565       else
5566         {
5567           argarray[j++] = VEC_index (tree, args, arg_index);
5568           ++arg_index;
5569         }
5570       parm = TREE_CHAIN (parm);
5571       /* We should never try to call the abstract constructor.  */
5572       gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
5573
5574       if (DECL_HAS_VTT_PARM_P (fn))
5575         {
5576           argarray[j++] = VEC_index (tree, args, arg_index);
5577           ++arg_index;
5578           parm = TREE_CHAIN (parm);
5579         }
5580     }
5581   /* Bypass access control for 'this' parameter.  */
5582   else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5583     {
5584       tree parmtype = TREE_VALUE (parm);
5585       tree arg = (first_arg != NULL_TREE
5586                   ? first_arg
5587                   : VEC_index (tree, args, arg_index));
5588       tree argtype = TREE_TYPE (arg);
5589       tree converted_arg;
5590       tree base_binfo;
5591
5592       if (convs[i]->bad_p)
5593         {
5594           if (complain & tf_error)
5595             permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers",
5596                        TREE_TYPE (argtype), fn);
5597           else
5598             return error_mark_node;
5599         }
5600
5601       /* [class.mfct.nonstatic]: If a nonstatic member function of a class
5602          X is called for an object that is not of type X, or of a type
5603          derived from X, the behavior is undefined.
5604
5605          So we can assume that anything passed as 'this' is non-null, and
5606          optimize accordingly.  */
5607       gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
5608       /* Convert to the base in which the function was declared.  */
5609       gcc_assert (cand->conversion_path != NULL_TREE);
5610       converted_arg = build_base_path (PLUS_EXPR,
5611                                        arg,
5612                                        cand->conversion_path,
5613                                        1);
5614       /* Check that the base class is accessible.  */
5615       if (!accessible_base_p (TREE_TYPE (argtype),
5616                               BINFO_TYPE (cand->conversion_path), true))
5617         error ("%qT is not an accessible base of %qT",
5618                BINFO_TYPE (cand->conversion_path),
5619                TREE_TYPE (argtype));
5620       /* If fn was found by a using declaration, the conversion path
5621          will be to the derived class, not the base declaring fn. We
5622          must convert from derived to base.  */
5623       base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
5624                                 TREE_TYPE (parmtype), ba_unique, NULL);
5625       converted_arg = build_base_path (PLUS_EXPR, converted_arg,
5626                                        base_binfo, 1);
5627
5628       argarray[j++] = converted_arg;
5629       parm = TREE_CHAIN (parm);
5630       if (first_arg != NULL_TREE)
5631         first_arg = NULL_TREE;
5632       else
5633         ++arg_index;
5634       ++i;
5635       is_method = 1;
5636     }
5637
5638   gcc_assert (first_arg == NULL_TREE);
5639   for (; arg_index < VEC_length (tree, args) && parm;
5640        parm = TREE_CHAIN (parm), ++arg_index, ++i)
5641     {
5642       tree type = TREE_VALUE (parm);
5643
5644       conv = convs[i];
5645
5646       /* Don't make a copy here if build_call is going to.  */
5647       if (conv->kind == ck_rvalue
5648           && COMPLETE_TYPE_P (complete_type (type))
5649           && !TREE_ADDRESSABLE (type))
5650         conv = conv->u.next;
5651
5652       /* Warn about initializer_list deduction that isn't currently in the
5653          working draft.  */
5654       if (cxx_dialect > cxx98
5655           && flag_deduce_init_list
5656           && cand->template_decl
5657           && is_std_init_list (non_reference (type)))
5658         {
5659           tree tmpl = TI_TEMPLATE (cand->template_decl);
5660           tree realparm = chain_index (j, DECL_ARGUMENTS (cand->fn));
5661           tree patparm = get_pattern_parm (realparm, tmpl);
5662           tree pattype = TREE_TYPE (patparm);
5663           if (PACK_EXPANSION_P (pattype))
5664             pattype = PACK_EXPANSION_PATTERN (pattype);
5665           pattype = non_reference (pattype);
5666
5667           if (!is_std_init_list (pattype))
5668             {
5669               pedwarn (input_location, 0, "deducing %qT as %qT",
5670                        non_reference (TREE_TYPE (patparm)),
5671                        non_reference (type));
5672               pedwarn (input_location, 0, "  in call to %q+D", cand->fn);
5673               pedwarn (input_location, 0,
5674                        "  (you can disable this with -fno-deduce-init-list)");
5675             }
5676         }
5677
5678       val = convert_like_with_context
5679         (conv, VEC_index (tree, args, arg_index), fn, i - is_method,
5680          complain);
5681
5682       val = convert_for_arg_passing (type, val);
5683       if (val == error_mark_node)
5684         return error_mark_node;
5685       else
5686         argarray[j++] = val;
5687     }
5688
5689   /* Default arguments */
5690   for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
5691     argarray[j++] = convert_default_arg (TREE_VALUE (parm),
5692                                          TREE_PURPOSE (parm),
5693                                          fn, i - is_method);
5694   /* Ellipsis */
5695   for (; arg_index < VEC_length (tree, args); ++arg_index)
5696     {
5697       tree a = VEC_index (tree, args, arg_index);
5698       if (magic_varargs_p (fn))
5699         /* Do no conversions for magic varargs.  */;
5700       else
5701         a = convert_arg_to_ellipsis (a);
5702       argarray[j++] = a;
5703     }
5704
5705   gcc_assert (j <= nargs);
5706   nargs = j;
5707
5708   check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
5709                             nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
5710
5711   /* Avoid actually calling copy constructors and copy assignment operators,
5712      if possible.  */
5713
5714   if (! flag_elide_constructors)
5715     /* Do things the hard way.  */;
5716   else if (cand->num_convs == 1
5717            && (DECL_COPY_CONSTRUCTOR_P (fn)
5718                || DECL_MOVE_CONSTRUCTOR_P (fn)))
5719     {
5720       tree targ;
5721       tree arg = argarray[num_artificial_parms_for (fn)];
5722       tree fa;
5723
5724       /* Pull out the real argument, disregarding const-correctness.  */
5725       targ = arg;
5726       while (CONVERT_EXPR_P (targ)
5727              || TREE_CODE (targ) == NON_LVALUE_EXPR)
5728         targ = TREE_OPERAND (targ, 0);
5729       if (TREE_CODE (targ) == ADDR_EXPR)
5730         {
5731           targ = TREE_OPERAND (targ, 0);
5732           if (!same_type_ignoring_top_level_qualifiers_p
5733               (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
5734             targ = NULL_TREE;
5735         }
5736       else
5737         targ = NULL_TREE;
5738
5739       if (targ)
5740         arg = targ;
5741       else
5742         arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5743
5744       if (TREE_CODE (arg) == TARGET_EXPR
5745           && TARGET_EXPR_LIST_INIT_P (arg))
5746         {
5747           /* Copy-list-initialization doesn't require the copy constructor
5748              to be defined.  */
5749         }
5750       /* [class.copy]: the copy constructor is implicitly defined even if
5751          the implementation elided its use.  */
5752       else if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
5753         {
5754           mark_used (fn);
5755           already_used = true;
5756         }
5757
5758       /* If we're creating a temp and we already have one, don't create a
5759          new one.  If we're not creating a temp but we get one, use
5760          INIT_EXPR to collapse the temp into our target.  Otherwise, if the
5761          ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5762          temp or an INIT_EXPR otherwise.  */
5763       fa = (cand->first_arg != NULL_TREE
5764             ? cand->first_arg
5765             : VEC_index (tree, args, 0));
5766       if (integer_zerop (fa))
5767         {
5768           if (TREE_CODE (arg) == TARGET_EXPR)
5769             return arg;
5770           else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
5771             return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
5772         }
5773       else if (TREE_CODE (arg) == TARGET_EXPR
5774                || (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5775                    && !move_fn_p (fn)))
5776         {
5777           tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL,
5778                                                                 complain));
5779           tree type = TREE_TYPE (to);
5780
5781           if (TREE_CODE (arg) != TARGET_EXPR
5782               && TREE_CODE (arg) != AGGR_INIT_EXPR
5783               && is_really_empty_class (type))
5784             {
5785               /* Avoid copying empty classes.  */
5786               val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
5787               TREE_NO_WARNING (val) = 1;
5788               val = build2 (COMPOUND_EXPR, type, val, to);
5789               TREE_NO_WARNING (val) = 1;
5790             }
5791           else
5792             val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5793           return val;
5794         }
5795     }
5796   else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
5797            && copy_fn_p (fn)
5798            && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
5799     {
5800       tree to = stabilize_reference
5801         (cp_build_indirect_ref (argarray[0], RO_NULL, complain));
5802       tree type = TREE_TYPE (to);
5803       tree as_base = CLASSTYPE_AS_BASE (type);
5804       tree arg = argarray[1];
5805
5806       if (is_really_empty_class (type))
5807         {
5808           /* Avoid copying empty classes.  */
5809           val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
5810           TREE_NO_WARNING (val) = 1;
5811           val = build2 (COMPOUND_EXPR, type, val, to);
5812           TREE_NO_WARNING (val) = 1;
5813         }
5814       else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5815         {
5816           arg = cp_build_indirect_ref (arg, RO_NULL, complain);
5817           val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5818         }
5819       else
5820         {
5821           /* We must only copy the non-tail padding parts.
5822              Use __builtin_memcpy for the bitwise copy.
5823              FIXME fix 22488 so we can go back to using MODIFY_EXPR
5824              instead of an explicit call to memcpy.  */
5825
5826           tree arg0, arg1, arg2, t;
5827           tree test = NULL_TREE;
5828
5829           arg2 = TYPE_SIZE_UNIT (as_base);
5830           arg1 = arg;
5831           arg0 = cp_build_unary_op (ADDR_EXPR, to, 0, complain);
5832
5833           if (!can_trust_pointer_alignment ())
5834             {
5835               /* If we can't be sure about pointer alignment, a call
5836                  to __builtin_memcpy is expanded as a call to memcpy, which
5837                  is invalid with identical args.  Otherwise it is
5838                  expanded as a block move, which should be safe.  */
5839               arg0 = save_expr (arg0);
5840               arg1 = save_expr (arg1);
5841               test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
5842             }
5843           t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5844           t = build_call_n (t, 3, arg0, arg1, arg2);
5845
5846           t = convert (TREE_TYPE (arg0), t);
5847           if (test)
5848             t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
5849           val = cp_build_indirect_ref (t, RO_NULL, complain);
5850           TREE_NO_WARNING (val) = 1;
5851         }
5852
5853       return val;
5854     }
5855
5856   if (!already_used)
5857     mark_used (fn);
5858
5859   if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5860     {
5861       tree t;
5862       tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
5863                                 DECL_CONTEXT (fn),
5864                                 ba_any, NULL);
5865       gcc_assert (binfo && binfo != error_mark_node);
5866
5867       /* Warn about deprecated virtual functions now, since we're about
5868          to throw away the decl.  */
5869       if (TREE_DEPRECATED (fn))
5870         warn_deprecated_use (fn, NULL_TREE);
5871
5872       argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
5873       if (TREE_SIDE_EFFECTS (argarray[0]))
5874         argarray[0] = save_expr (argarray[0]);
5875       t = build_pointer_type (TREE_TYPE (fn));
5876       if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5877         fn = build_java_interface_fn_ref (fn, argarray[0]);
5878       else
5879         fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
5880       TREE_TYPE (fn) = t;
5881     }
5882   else
5883     fn = build_addr_func (fn);
5884
5885   return build_cxx_call (fn, nargs, argarray);
5886 }
5887
5888 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5889    This function performs no overload resolution, conversion, or other
5890    high-level operations.  */
5891
5892 tree
5893 build_cxx_call (tree fn, int nargs, tree *argarray)
5894 {
5895   tree fndecl;
5896
5897   fn = build_call_a (fn, nargs, argarray);
5898
5899   /* If this call might throw an exception, note that fact.  */
5900   fndecl = get_callee_fndecl (fn);
5901   if ((!fndecl || !TREE_NOTHROW (fndecl))
5902       && at_function_scope_p ()
5903       && cfun)
5904     cp_function_chain->can_throw = 1;
5905
5906   /* Check that arguments to builtin functions match the expectations.  */
5907   if (fndecl
5908       && DECL_BUILT_IN (fndecl)
5909       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
5910       && !check_builtin_function_arguments (fndecl, nargs, argarray))
5911     return error_mark_node;
5912
5913   /* Some built-in function calls will be evaluated at compile-time in
5914      fold ().  */
5915   fn = fold_if_not_in_template (fn);
5916
5917   if (VOID_TYPE_P (TREE_TYPE (fn)))
5918     return fn;
5919
5920   fn = require_complete_type (fn);
5921   if (fn == error_mark_node)
5922     return error_mark_node;
5923
5924   if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
5925     fn = build_cplus_new (TREE_TYPE (fn), fn);
5926   return convert_from_reference (fn);
5927 }
5928
5929 static GTY(()) tree java_iface_lookup_fn;
5930
5931 /* Make an expression which yields the address of the Java interface
5932    method FN.  This is achieved by generating a call to libjava's
5933    _Jv_LookupInterfaceMethodIdx().  */
5934
5935 static tree
5936 build_java_interface_fn_ref (tree fn, tree instance)
5937 {
5938   tree lookup_fn, method, idx;
5939   tree klass_ref, iface, iface_ref;
5940   int i;
5941
5942   if (!java_iface_lookup_fn)
5943     {
5944       tree endlink = build_void_list_node ();
5945       tree t = tree_cons (NULL_TREE, ptr_type_node,
5946                           tree_cons (NULL_TREE, ptr_type_node,
5947                                      tree_cons (NULL_TREE, java_int_type_node,
5948                                                 endlink)));
5949       java_iface_lookup_fn
5950         = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
5951                                 build_function_type (ptr_type_node, t),
5952                                 0, NOT_BUILT_IN, NULL, NULL_TREE);
5953     }
5954
5955   /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5956      This is the first entry in the vtable.  */
5957   klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL,
5958                                                      tf_warning_or_error),
5959                               integer_zero_node);
5960
5961   /* Get the java.lang.Class pointer for the interface being called.  */
5962   iface = DECL_CONTEXT (fn);
5963   iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5964   if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5965       || DECL_CONTEXT (iface_ref) != iface)
5966     {
5967       error ("could not find class$ field in java interface type %qT",
5968                 iface);
5969       return error_mark_node;
5970     }
5971   iface_ref = build_address (iface_ref);
5972   iface_ref = convert (build_pointer_type (iface), iface_ref);
5973
5974   /* Determine the itable index of FN.  */
5975   i = 1;
5976   for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5977     {
5978       if (!DECL_VIRTUAL_P (method))
5979         continue;
5980       if (fn == method)
5981         break;
5982       i++;
5983     }
5984   idx = build_int_cst (NULL_TREE, i);
5985
5986   lookup_fn = build1 (ADDR_EXPR,
5987                       build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5988                       java_iface_lookup_fn);
5989   return build_call_nary (ptr_type_node, lookup_fn,
5990                           3, klass_ref, iface_ref, idx);
5991 }
5992
5993 /* Returns the value to use for the in-charge parameter when making a
5994    call to a function with the indicated NAME.
5995
5996    FIXME:Can't we find a neater way to do this mapping?  */
5997
5998 tree
5999 in_charge_arg_for_name (tree name)
6000 {
6001  if (name == base_ctor_identifier
6002       || name == base_dtor_identifier)
6003     return integer_zero_node;
6004   else if (name == complete_ctor_identifier)
6005     return integer_one_node;
6006   else if (name == complete_dtor_identifier)
6007     return integer_two_node;
6008   else if (name == deleting_dtor_identifier)
6009     return integer_three_node;
6010
6011   /* This function should only be called with one of the names listed
6012      above.  */
6013   gcc_unreachable ();
6014   return NULL_TREE;
6015 }
6016
6017 /* Build a call to a constructor, destructor, or an assignment
6018    operator for INSTANCE, an expression with class type.  NAME
6019    indicates the special member function to call; *ARGS are the
6020    arguments.  ARGS may be NULL.  This may change ARGS.  BINFO
6021    indicates the base of INSTANCE that is to be passed as the `this'
6022    parameter to the member function called.
6023
6024    FLAGS are the LOOKUP_* flags to use when processing the call.
6025
6026    If NAME indicates a complete object constructor, INSTANCE may be
6027    NULL_TREE.  In this case, the caller will call build_cplus_new to
6028    store the newly constructed object into a VAR_DECL.  */
6029
6030 tree
6031 build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
6032                            tree binfo, int flags, tsubst_flags_t complain)
6033 {
6034   tree fns;
6035   /* The type of the subobject to be constructed or destroyed.  */
6036   tree class_type;
6037   VEC(tree,gc) *allocated = NULL;
6038   tree ret;
6039
6040   gcc_assert (name == complete_ctor_identifier
6041               || name == base_ctor_identifier
6042               || name == complete_dtor_identifier
6043               || name == base_dtor_identifier
6044               || name == deleting_dtor_identifier
6045               || name == ansi_assopname (NOP_EXPR));
6046   if (TYPE_P (binfo))
6047     {
6048       /* Resolve the name.  */
6049       if (!complete_type_or_else (binfo, NULL_TREE))
6050         return error_mark_node;
6051
6052       binfo = TYPE_BINFO (binfo);
6053     }
6054
6055   gcc_assert (binfo != NULL_TREE);
6056
6057   class_type = BINFO_TYPE (binfo);
6058
6059   /* Handle the special case where INSTANCE is NULL_TREE.  */
6060   if (name == complete_ctor_identifier && !instance)
6061     {
6062       instance = build_int_cst (build_pointer_type (class_type), 0);
6063       instance = build1 (INDIRECT_REF, class_type, instance);
6064     }
6065   else
6066     {
6067       if (name == complete_dtor_identifier
6068           || name == base_dtor_identifier
6069           || name == deleting_dtor_identifier)
6070         gcc_assert (args == NULL || VEC_empty (tree, *args));
6071
6072       /* Convert to the base class, if necessary.  */
6073       if (!same_type_ignoring_top_level_qualifiers_p
6074           (TREE_TYPE (instance), BINFO_TYPE (binfo)))
6075         {
6076           if (name != ansi_assopname (NOP_EXPR))
6077             /* For constructors and destructors, either the base is
6078                non-virtual, or it is virtual but we are doing the
6079                conversion from a constructor or destructor for the
6080                complete object.  In either case, we can convert
6081                statically.  */
6082             instance = convert_to_base_statically (instance, binfo);
6083           else
6084             /* However, for assignment operators, we must convert
6085                dynamically if the base is virtual.  */
6086             instance = build_base_path (PLUS_EXPR, instance,
6087                                         binfo, /*nonnull=*/1);
6088         }
6089     }
6090
6091   gcc_assert (instance != NULL_TREE);
6092
6093   fns = lookup_fnfields (binfo, name, 1);
6094
6095   /* When making a call to a constructor or destructor for a subobject
6096      that uses virtual base classes, pass down a pointer to a VTT for
6097      the subobject.  */
6098   if ((name == base_ctor_identifier
6099        || name == base_dtor_identifier)
6100       && CLASSTYPE_VBASECLASSES (class_type))
6101     {
6102       tree vtt;
6103       tree sub_vtt;
6104
6105       /* If the current function is a complete object constructor
6106          or destructor, then we fetch the VTT directly.
6107          Otherwise, we look it up using the VTT we were given.  */
6108       vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
6109       vtt = decay_conversion (vtt);
6110       vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
6111                     build2 (EQ_EXPR, boolean_type_node,
6112                             current_in_charge_parm, integer_zero_node),
6113                     current_vtt_parm,
6114                     vtt);
6115       gcc_assert (BINFO_SUBVTT_INDEX (binfo));
6116       sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
6117                         BINFO_SUBVTT_INDEX (binfo));
6118
6119       if (args == NULL)
6120         {
6121           allocated = make_tree_vector ();
6122           args = &allocated;
6123         }
6124
6125       VEC_safe_insert (tree, gc, *args, 0, sub_vtt);
6126     }
6127
6128   ret = build_new_method_call (instance, fns, args,
6129                                TYPE_BINFO (BINFO_TYPE (binfo)),
6130                                flags, /*fn=*/NULL,
6131                                complain);
6132
6133   if (allocated != NULL)
6134     release_tree_vector (allocated);
6135
6136   return ret;
6137 }
6138
6139 /* Return the NAME, as a C string.  The NAME indicates a function that
6140    is a member of TYPE.  *FREE_P is set to true if the caller must
6141    free the memory returned.
6142
6143    Rather than go through all of this, we should simply set the names
6144    of constructors and destructors appropriately, and dispense with
6145    ctor_identifier, dtor_identifier, etc.  */
6146
6147 static char *
6148 name_as_c_string (tree name, tree type, bool *free_p)
6149 {
6150   char *pretty_name;
6151
6152   /* Assume that we will not allocate memory.  */
6153   *free_p = false;
6154   /* Constructors and destructors are special.  */
6155   if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6156     {
6157       pretty_name
6158         = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
6159       /* For a destructor, add the '~'.  */
6160       if (name == complete_dtor_identifier
6161           || name == base_dtor_identifier
6162           || name == deleting_dtor_identifier)
6163         {
6164           pretty_name = concat ("~", pretty_name, NULL);
6165           /* Remember that we need to free the memory allocated.  */
6166           *free_p = true;
6167         }
6168     }
6169   else if (IDENTIFIER_TYPENAME_P (name))
6170     {
6171       pretty_name = concat ("operator ",
6172                             type_as_string_translate (TREE_TYPE (name),
6173                                                       TFF_PLAIN_IDENTIFIER),
6174                             NULL);
6175       /* Remember that we need to free the memory allocated.  */
6176       *free_p = true;
6177     }
6178   else
6179     pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
6180
6181   return pretty_name;
6182 }
6183
6184 /* Build a call to "INSTANCE.FN (ARGS)".  If FN_P is non-NULL, it will
6185    be set, upon return, to the function called.  ARGS may be NULL.
6186    This may change ARGS.  */
6187
6188 tree
6189 build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
6190                        tree conversion_path, int flags,
6191                        tree *fn_p, tsubst_flags_t complain)
6192 {
6193   struct z_candidate *candidates = 0, *cand;
6194   tree explicit_targs = NULL_TREE;
6195   tree basetype = NULL_TREE;
6196   tree access_binfo;
6197   tree optype;
6198   tree first_mem_arg = NULL_TREE;
6199   tree instance_ptr;
6200   tree name;
6201   bool skip_first_for_error;
6202   VEC(tree,gc) *user_args;
6203   tree call;
6204   tree fn;
6205   tree class_type;
6206   int template_only = 0;
6207   bool any_viable_p;
6208   tree orig_instance;
6209   tree orig_fns;
6210   VEC(tree,gc) *orig_args = NULL;
6211   void *p;
6212
6213   gcc_assert (instance != NULL_TREE);
6214
6215   /* We don't know what function we're going to call, yet.  */
6216   if (fn_p)
6217     *fn_p = NULL_TREE;
6218
6219   if (error_operand_p (instance)
6220       || error_operand_p (fns))
6221     return error_mark_node;
6222
6223   if (!BASELINK_P (fns))
6224     {
6225       if (complain & tf_error)
6226         error ("call to non-function %qD", fns);
6227       return error_mark_node;
6228     }
6229
6230   orig_instance = instance;
6231   orig_fns = fns;
6232
6233   /* Dismantle the baselink to collect all the information we need.  */
6234   if (!conversion_path)
6235     conversion_path = BASELINK_BINFO (fns);
6236   access_binfo = BASELINK_ACCESS_BINFO (fns);
6237   optype = BASELINK_OPTYPE (fns);
6238   fns = BASELINK_FUNCTIONS (fns);
6239   if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
6240     {
6241       explicit_targs = TREE_OPERAND (fns, 1);
6242       fns = TREE_OPERAND (fns, 0);
6243       template_only = 1;
6244     }
6245   gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
6246               || TREE_CODE (fns) == TEMPLATE_DECL
6247               || TREE_CODE (fns) == OVERLOAD);
6248   fn = get_first_fn (fns);
6249   name = DECL_NAME (fn);
6250
6251   basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
6252   gcc_assert (CLASS_TYPE_P (basetype));
6253
6254   if (processing_template_decl)
6255     {
6256       orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
6257       instance = build_non_dependent_expr (instance);
6258       if (args != NULL)
6259         make_args_non_dependent (*args);
6260     }
6261
6262   user_args = args == NULL ? NULL : *args;
6263   /* Under DR 147 A::A() is an invalid constructor call,
6264      not a functional cast.  */
6265   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
6266     {
6267       if (! (complain & tf_error))
6268         return error_mark_node;
6269
6270       permerror (input_location,
6271                  "cannot call constructor %<%T::%D%> directly",
6272                  basetype, name);
6273       permerror (input_location, "  for a function-style cast, remove the "
6274                  "redundant %<::%D%>", name);
6275       call = build_functional_cast (basetype, build_tree_list_vec (user_args),
6276                                     complain);
6277       return call;
6278     }
6279
6280   /* Figure out whether to skip the first argument for the error
6281      message we will display to users if an error occurs.  We don't
6282      want to display any compiler-generated arguments.  The "this"
6283      pointer hasn't been added yet.  However, we must remove the VTT
6284      pointer if this is a call to a base-class constructor or
6285      destructor.  */
6286   skip_first_for_error = false;
6287   if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6288     {
6289       /* Callers should explicitly indicate whether they want to construct
6290          the complete object or just the part without virtual bases.  */
6291       gcc_assert (name != ctor_identifier);
6292       /* Similarly for destructors.  */
6293       gcc_assert (name != dtor_identifier);
6294       /* Remove the VTT pointer, if present.  */
6295       if ((name == base_ctor_identifier || name == base_dtor_identifier)
6296           && CLASSTYPE_VBASECLASSES (basetype))
6297         skip_first_for_error = true;
6298     }
6299
6300   /* Process the argument list.  */
6301   if (args != NULL && *args != NULL)
6302     {
6303       *args = resolve_args (*args);
6304       if (*args == NULL)
6305         return error_mark_node;
6306     }
6307
6308   instance_ptr = build_this (instance);
6309
6310   /* It's OK to call destructors and constructors on cv-qualified objects.
6311      Therefore, convert the INSTANCE_PTR to the unqualified type, if
6312      necessary.  */
6313   if (DECL_DESTRUCTOR_P (fn)
6314       || DECL_CONSTRUCTOR_P (fn))
6315     {
6316       tree type = build_pointer_type (basetype);
6317       if (!same_type_p (type, TREE_TYPE (instance_ptr)))
6318         instance_ptr = build_nop (type, instance_ptr);
6319     }
6320   if (DECL_DESTRUCTOR_P (fn))
6321     name = complete_dtor_identifier;
6322
6323   /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
6324      initializer, not T({ }).  If the type doesn't have a list ctor,
6325      break apart the list into separate ctor args.  */
6326   if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !VEC_empty (tree, *args)
6327       && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *args, 0))
6328       && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *args, 0))
6329       && !TYPE_HAS_LIST_CTOR (basetype))
6330     {
6331       gcc_assert (VEC_length (tree, *args) == 1);
6332       *args = ctor_to_vec (VEC_index (tree, *args, 0));
6333     }
6334
6335   class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
6336   first_mem_arg = instance_ptr;
6337
6338   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
6339   p = conversion_obstack_alloc (0);
6340
6341   for (fn = fns; fn; fn = OVL_NEXT (fn))
6342     {
6343       tree t = OVL_CURRENT (fn);
6344       tree this_first_arg;
6345
6346       /* We can end up here for copy-init of same or base class.  */
6347       if ((flags & LOOKUP_ONLYCONVERTING)
6348           && DECL_NONCONVERTING_P (t))
6349         continue;
6350
6351       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
6352         this_first_arg = first_mem_arg;
6353       else
6354         this_first_arg = NULL_TREE;
6355
6356       if (TREE_CODE (t) == TEMPLATE_DECL)
6357         /* A member template.  */
6358         add_template_candidate (&candidates, t,
6359                                 class_type,
6360                                 explicit_targs,
6361                                 this_first_arg,
6362                                 args == NULL ? NULL : *args,
6363                                 optype,
6364                                 access_binfo,
6365                                 conversion_path,
6366                                 flags,
6367                                 DEDUCE_CALL);
6368       else if (! template_only)
6369         add_function_candidate (&candidates, t,
6370                                 class_type,
6371                                 this_first_arg,
6372                                 args == NULL ? NULL : *args,
6373                                 access_binfo,
6374                                 conversion_path,
6375                                 flags);
6376     }
6377
6378   candidates = splice_viable (candidates, pedantic, &any_viable_p);
6379   if (!any_viable_p)
6380     {
6381       if (complain & tf_error)
6382         {
6383           if (!COMPLETE_TYPE_P (basetype))
6384             cxx_incomplete_type_error (instance_ptr, basetype);
6385           else
6386             {
6387               char *pretty_name;
6388               bool free_p;
6389               tree arglist;
6390
6391               pretty_name = name_as_c_string (name, basetype, &free_p);
6392               arglist = build_tree_list_vec (user_args);
6393               if (skip_first_for_error)
6394                 arglist = TREE_CHAIN (arglist);
6395               error ("no matching function for call to %<%T::%s(%A)%#V%>",
6396                      basetype, pretty_name, arglist,
6397                      TREE_TYPE (TREE_TYPE (instance_ptr)));
6398               if (free_p)
6399                 free (pretty_name);
6400             }
6401           print_z_candidates (candidates);
6402         }
6403       call = error_mark_node;
6404     }
6405   else
6406     {
6407       cand = tourney (candidates);
6408       if (cand == 0)
6409         {
6410           char *pretty_name;
6411           bool free_p;
6412           tree arglist;
6413
6414           if (complain & tf_error)
6415             {
6416               pretty_name = name_as_c_string (name, basetype, &free_p);
6417               arglist = build_tree_list_vec (user_args);
6418               if (skip_first_for_error)
6419                 arglist = TREE_CHAIN (arglist);
6420               error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
6421                      arglist);
6422               print_z_candidates (candidates);
6423               if (free_p)
6424                 free (pretty_name);
6425             }
6426           call = error_mark_node;
6427         }
6428       else
6429         {
6430           fn = cand->fn;
6431
6432           if (!(flags & LOOKUP_NONVIRTUAL)
6433               && DECL_PURE_VIRTUAL_P (fn)
6434               && instance == current_class_ref
6435               && (DECL_CONSTRUCTOR_P (current_function_decl)
6436                   || DECL_DESTRUCTOR_P (current_function_decl))
6437               && (complain & tf_warning))
6438             /* This is not an error, it is runtime undefined
6439                behavior.  */
6440             warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
6441                       "abstract virtual %q#D called from constructor"
6442                       : "abstract virtual %q#D called from destructor"),
6443                      fn);
6444
6445           if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
6446               && is_dummy_object (instance_ptr))
6447             {
6448               if (complain & tf_error)
6449                 error ("cannot call member function %qD without object",
6450                        fn);
6451               call = error_mark_node;
6452             }
6453           else
6454             {
6455               if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
6456                   && resolves_to_fixed_type_p (instance, 0))
6457                 flags |= LOOKUP_NONVIRTUAL;
6458               /* Now we know what function is being called.  */
6459               if (fn_p)
6460                 *fn_p = fn;
6461               /* Build the actual CALL_EXPR.  */
6462               call = build_over_call (cand, flags, complain);
6463               /* In an expression of the form `a->f()' where `f' turns
6464                  out to be a static member function, `a' is
6465                  none-the-less evaluated.  */
6466               if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
6467                   && !is_dummy_object (instance_ptr)
6468                   && TREE_SIDE_EFFECTS (instance_ptr))
6469                 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
6470                                instance_ptr, call);
6471               else if (call != error_mark_node
6472                        && DECL_DESTRUCTOR_P (cand->fn)
6473                        && !VOID_TYPE_P (TREE_TYPE (call)))
6474                 /* An explicit call of the form "x->~X()" has type
6475                    "void".  However, on platforms where destructors
6476                    return "this" (i.e., those where
6477                    targetm.cxx.cdtor_returns_this is true), such calls
6478                    will appear to have a return value of pointer type
6479                    to the low-level call machinery.  We do not want to
6480                    change the low-level machinery, since we want to be
6481                    able to optimize "delete f()" on such platforms as
6482                    "operator delete(~X(f()))" (rather than generating
6483                    "t = f(), ~X(t), operator delete (t)").  */
6484                 call = build_nop (void_type_node, call);
6485             }
6486         }
6487     }
6488
6489   if (processing_template_decl && call != error_mark_node)
6490     {
6491       bool cast_to_void = false;
6492
6493       if (TREE_CODE (call) == COMPOUND_EXPR)
6494         call = TREE_OPERAND (call, 1);
6495       else if (TREE_CODE (call) == NOP_EXPR)
6496         {
6497           cast_to_void = true;
6498           call = TREE_OPERAND (call, 0);
6499         }
6500       if (TREE_CODE (call) == INDIRECT_REF)
6501         call = TREE_OPERAND (call, 0);
6502       call = (build_min_non_dep_call_vec
6503               (call,
6504                build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
6505                           orig_instance, orig_fns, NULL_TREE),
6506                orig_args));
6507       call = convert_from_reference (call);
6508       if (cast_to_void)
6509         call = build_nop (void_type_node, call);
6510     }
6511
6512  /* Free all the conversions we allocated.  */
6513   obstack_free (&conversion_obstack, p);
6514
6515   if (orig_args != NULL)
6516     release_tree_vector (orig_args);
6517
6518   return call;
6519 }
6520
6521 /* Returns true iff standard conversion sequence ICS1 is a proper
6522    subsequence of ICS2.  */
6523
6524 static bool
6525 is_subseq (conversion *ics1, conversion *ics2)
6526 {
6527   /* We can assume that a conversion of the same code
6528      between the same types indicates a subsequence since we only get
6529      here if the types we are converting from are the same.  */
6530
6531   while (ics1->kind == ck_rvalue
6532          || ics1->kind == ck_lvalue)
6533     ics1 = ics1->u.next;
6534
6535   while (1)
6536     {
6537       while (ics2->kind == ck_rvalue
6538              || ics2->kind == ck_lvalue)
6539         ics2 = ics2->u.next;
6540
6541       if (ics2->kind == ck_user
6542           || ics2->kind == ck_ambig
6543           || ics2->kind == ck_identity)
6544         /* At this point, ICS1 cannot be a proper subsequence of
6545            ICS2.  We can get a USER_CONV when we are comparing the
6546            second standard conversion sequence of two user conversion
6547            sequences.  */
6548         return false;
6549
6550       ics2 = ics2->u.next;
6551
6552       if (ics2->kind == ics1->kind
6553           && same_type_p (ics2->type, ics1->type)
6554           && same_type_p (ics2->u.next->type,
6555                           ics1->u.next->type))
6556         return true;
6557     }
6558 }
6559
6560 /* Returns nonzero iff DERIVED is derived from BASE.  The inputs may
6561    be any _TYPE nodes.  */
6562
6563 bool
6564 is_properly_derived_from (tree derived, tree base)
6565 {
6566   if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
6567     return false;
6568
6569   /* We only allow proper derivation here.  The DERIVED_FROM_P macro
6570      considers every class derived from itself.  */
6571   return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
6572           && DERIVED_FROM_P (base, derived));
6573 }
6574
6575 /* We build the ICS for an implicit object parameter as a pointer
6576    conversion sequence.  However, such a sequence should be compared
6577    as if it were a reference conversion sequence.  If ICS is the
6578    implicit conversion sequence for an implicit object parameter,
6579    modify it accordingly.  */
6580
6581 static void
6582 maybe_handle_implicit_object (conversion **ics)
6583 {
6584   if ((*ics)->this_p)
6585     {
6586       /* [over.match.funcs]
6587
6588          For non-static member functions, the type of the
6589          implicit object parameter is "reference to cv X"
6590          where X is the class of which the function is a
6591          member and cv is the cv-qualification on the member
6592          function declaration.  */
6593       conversion *t = *ics;
6594       tree reference_type;
6595
6596       /* The `this' parameter is a pointer to a class type.  Make the
6597          implicit conversion talk about a reference to that same class
6598          type.  */
6599       reference_type = TREE_TYPE (t->type);
6600       reference_type = build_reference_type (reference_type);
6601
6602       if (t->kind == ck_qual)
6603         t = t->u.next;
6604       if (t->kind == ck_ptr)
6605         t = t->u.next;
6606       t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
6607       t = direct_reference_binding (reference_type, t);
6608       t->this_p = 1;
6609       t->rvaluedness_matches_p = 0;
6610       *ics = t;
6611     }
6612 }
6613
6614 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
6615    and return the initial reference binding conversion. Otherwise,
6616    leave *ICS unchanged and return NULL.  */
6617
6618 static conversion *
6619 maybe_handle_ref_bind (conversion **ics)
6620 {
6621   if ((*ics)->kind == ck_ref_bind)
6622     {
6623       conversion *old_ics = *ics;
6624       *ics = old_ics->u.next;
6625       (*ics)->user_conv_p = old_ics->user_conv_p;
6626       return old_ics;
6627     }
6628
6629   return NULL;
6630 }
6631
6632 /* Compare two implicit conversion sequences according to the rules set out in
6633    [over.ics.rank].  Return values:
6634
6635       1: ics1 is better than ics2
6636      -1: ics2 is better than ics1
6637       0: ics1 and ics2 are indistinguishable */
6638
6639 static int
6640 compare_ics (conversion *ics1, conversion *ics2)
6641 {
6642   tree from_type1;
6643   tree from_type2;
6644   tree to_type1;
6645   tree to_type2;
6646   tree deref_from_type1 = NULL_TREE;
6647   tree deref_from_type2 = NULL_TREE;
6648   tree deref_to_type1 = NULL_TREE;
6649   tree deref_to_type2 = NULL_TREE;
6650   conversion_rank rank1, rank2;
6651
6652   /* REF_BINDING is nonzero if the result of the conversion sequence
6653      is a reference type.   In that case REF_CONV is the reference
6654      binding conversion. */
6655   conversion *ref_conv1;
6656   conversion *ref_conv2;
6657
6658   /* Handle implicit object parameters.  */
6659   maybe_handle_implicit_object (&ics1);
6660   maybe_handle_implicit_object (&ics2);
6661
6662   /* Handle reference parameters.  */
6663   ref_conv1 = maybe_handle_ref_bind (&ics1);
6664   ref_conv2 = maybe_handle_ref_bind (&ics2);
6665
6666   /* List-initialization sequence L1 is a better conversion sequence than
6667      list-initialization sequence L2 if L1 converts to
6668      std::initializer_list<X> for some X and L2 does not.  */
6669   if (ics1->kind == ck_list && ics2->kind != ck_list)
6670     return 1;
6671   if (ics2->kind == ck_list && ics1->kind != ck_list)
6672     return -1;
6673
6674   /* [over.ics.rank]
6675
6676      When  comparing  the  basic forms of implicit conversion sequences (as
6677      defined in _over.best.ics_)
6678
6679      --a standard conversion sequence (_over.ics.scs_) is a better
6680        conversion sequence than a user-defined conversion sequence
6681        or an ellipsis conversion sequence, and
6682
6683      --a user-defined conversion sequence (_over.ics.user_) is a
6684        better conversion sequence than an ellipsis conversion sequence
6685        (_over.ics.ellipsis_).  */
6686   rank1 = CONVERSION_RANK (ics1);
6687   rank2 = CONVERSION_RANK (ics2);
6688
6689   if (rank1 > rank2)
6690     return -1;
6691   else if (rank1 < rank2)
6692     return 1;
6693
6694   if (rank1 == cr_bad)
6695     {
6696       /* XXX Isn't this an extension? */
6697       /* Both ICS are bad.  We try to make a decision based on what
6698          would have happened if they'd been good.  */
6699       if (ics1->user_conv_p > ics2->user_conv_p
6700           || ics1->rank  > ics2->rank)
6701         return -1;
6702       else if (ics1->user_conv_p < ics2->user_conv_p
6703                || ics1->rank < ics2->rank)
6704         return 1;
6705
6706       /* We couldn't make up our minds; try to figure it out below.  */
6707     }
6708
6709   if (ics1->ellipsis_p || ics1->kind == ck_list)
6710     /* Both conversions are ellipsis conversions or both are building a
6711        std::initializer_list.  */
6712     return 0;
6713
6714   /* User-defined  conversion sequence U1 is a better conversion sequence
6715      than another user-defined conversion sequence U2 if they contain the
6716      same user-defined conversion operator or constructor and if the sec-
6717      ond standard conversion sequence of U1 is  better  than  the  second
6718      standard conversion sequence of U2.  */
6719
6720   if (ics1->user_conv_p)
6721     {
6722       conversion *t1;
6723       conversion *t2;
6724
6725       for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
6726         if (t1->kind == ck_ambig || t1->kind == ck_aggr)
6727           return 0;
6728       for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
6729         if (t2->kind == ck_ambig || t2->kind == ck_aggr)
6730           return 0;
6731
6732       if (t1->cand->fn != t2->cand->fn)
6733         return 0;
6734
6735       /* We can just fall through here, after setting up
6736          FROM_TYPE1 and FROM_TYPE2.  */
6737       from_type1 = t1->type;
6738       from_type2 = t2->type;
6739     }
6740   else
6741     {
6742       conversion *t1;
6743       conversion *t2;
6744
6745       /* We're dealing with two standard conversion sequences.
6746
6747          [over.ics.rank]
6748
6749          Standard conversion sequence S1 is a better conversion
6750          sequence than standard conversion sequence S2 if
6751
6752          --S1 is a proper subsequence of S2 (comparing the conversion
6753            sequences in the canonical form defined by _over.ics.scs_,
6754            excluding any Lvalue Transformation; the identity
6755            conversion sequence is considered to be a subsequence of
6756            any non-identity conversion sequence */
6757
6758       t1 = ics1;
6759       while (t1->kind != ck_identity)
6760         t1 = t1->u.next;
6761       from_type1 = t1->type;
6762
6763       t2 = ics2;
6764       while (t2->kind != ck_identity)
6765         t2 = t2->u.next;
6766       from_type2 = t2->type;
6767     }
6768
6769   /* One sequence can only be a subsequence of the other if they start with
6770      the same type.  They can start with different types when comparing the
6771      second standard conversion sequence in two user-defined conversion
6772      sequences.  */
6773   if (same_type_p (from_type1, from_type2))
6774     {
6775       if (is_subseq (ics1, ics2))
6776         return 1;
6777       if (is_subseq (ics2, ics1))
6778         return -1;
6779     }
6780
6781   /* [over.ics.rank]
6782
6783      Or, if not that,
6784
6785      --the rank of S1 is better than the rank of S2 (by the rules
6786        defined below):
6787
6788     Standard conversion sequences are ordered by their ranks: an Exact
6789     Match is a better conversion than a Promotion, which is a better
6790     conversion than a Conversion.
6791
6792     Two conversion sequences with the same rank are indistinguishable
6793     unless one of the following rules applies:
6794
6795     --A conversion that is not a conversion of a pointer, or pointer
6796       to member, to bool is better than another conversion that is such
6797       a conversion.
6798
6799     The ICS_STD_RANK automatically handles the pointer-to-bool rule,
6800     so that we do not have to check it explicitly.  */
6801   if (ics1->rank < ics2->rank)
6802     return 1;
6803   else if (ics2->rank < ics1->rank)
6804     return -1;
6805
6806   to_type1 = ics1->type;
6807   to_type2 = ics2->type;
6808
6809   /* A conversion from scalar arithmetic type to complex is worse than a
6810      conversion between scalar arithmetic types.  */
6811   if (same_type_p (from_type1, from_type2)
6812       && ARITHMETIC_TYPE_P (from_type1)
6813       && ARITHMETIC_TYPE_P (to_type1)
6814       && ARITHMETIC_TYPE_P (to_type2)
6815       && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
6816           != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
6817     {
6818       if (TREE_CODE (to_type1) == COMPLEX_TYPE)
6819         return -1;
6820       else
6821         return 1;
6822     }
6823
6824   if (TYPE_PTR_P (from_type1)
6825       && TYPE_PTR_P (from_type2)
6826       && TYPE_PTR_P (to_type1)
6827       && TYPE_PTR_P (to_type2))
6828     {
6829       deref_from_type1 = TREE_TYPE (from_type1);
6830       deref_from_type2 = TREE_TYPE (from_type2);
6831       deref_to_type1 = TREE_TYPE (to_type1);
6832       deref_to_type2 = TREE_TYPE (to_type2);
6833     }
6834   /* The rules for pointers to members A::* are just like the rules
6835      for pointers A*, except opposite: if B is derived from A then
6836      A::* converts to B::*, not vice versa.  For that reason, we
6837      switch the from_ and to_ variables here.  */
6838   else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
6839             && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
6840            || (TYPE_PTRMEMFUNC_P (from_type1)
6841                && TYPE_PTRMEMFUNC_P (from_type2)
6842                && TYPE_PTRMEMFUNC_P (to_type1)
6843                && TYPE_PTRMEMFUNC_P (to_type2)))
6844     {
6845       deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
6846       deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
6847       deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
6848       deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
6849     }
6850
6851   if (deref_from_type1 != NULL_TREE
6852       && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
6853       && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
6854     {
6855       /* This was one of the pointer or pointer-like conversions.
6856
6857          [over.ics.rank]
6858
6859          --If class B is derived directly or indirectly from class A,
6860            conversion of B* to A* is better than conversion of B* to
6861            void*, and conversion of A* to void* is better than
6862            conversion of B* to void*.  */
6863       if (TREE_CODE (deref_to_type1) == VOID_TYPE
6864           && TREE_CODE (deref_to_type2) == VOID_TYPE)
6865         {
6866           if (is_properly_derived_from (deref_from_type1,
6867                                         deref_from_type2))
6868             return -1;
6869           else if (is_properly_derived_from (deref_from_type2,
6870                                              deref_from_type1))
6871             return 1;
6872         }
6873       else if (TREE_CODE (deref_to_type1) == VOID_TYPE
6874                || TREE_CODE (deref_to_type2) == VOID_TYPE)
6875         {
6876           if (same_type_p (deref_from_type1, deref_from_type2))
6877             {
6878               if (TREE_CODE (deref_to_type2) == VOID_TYPE)
6879                 {
6880                   if (is_properly_derived_from (deref_from_type1,
6881                                                 deref_to_type1))
6882                     return 1;
6883                 }
6884               /* We know that DEREF_TO_TYPE1 is `void' here.  */
6885               else if (is_properly_derived_from (deref_from_type1,
6886                                                  deref_to_type2))
6887                 return -1;
6888             }
6889         }
6890       else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
6891                && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
6892         {
6893           /* [over.ics.rank]
6894
6895              --If class B is derived directly or indirectly from class A
6896                and class C is derived directly or indirectly from B,
6897
6898              --conversion of C* to B* is better than conversion of C* to
6899                A*,
6900
6901              --conversion of B* to A* is better than conversion of C* to
6902                A*  */
6903           if (same_type_p (deref_from_type1, deref_from_type2))
6904             {
6905               if (is_properly_derived_from (deref_to_type1,
6906                                             deref_to_type2))
6907                 return 1;
6908               else if (is_properly_derived_from (deref_to_type2,
6909                                                  deref_to_type1))
6910                 return -1;
6911             }
6912           else if (same_type_p (deref_to_type1, deref_to_type2))
6913             {
6914               if (is_properly_derived_from (deref_from_type2,
6915                                             deref_from_type1))
6916                 return 1;
6917               else if (is_properly_derived_from (deref_from_type1,
6918                                                  deref_from_type2))
6919                 return -1;
6920             }
6921         }
6922     }
6923   else if (CLASS_TYPE_P (non_reference (from_type1))
6924            && same_type_p (from_type1, from_type2))
6925     {
6926       tree from = non_reference (from_type1);
6927
6928       /* [over.ics.rank]
6929
6930          --binding of an expression of type C to a reference of type
6931            B& is better than binding an expression of type C to a
6932            reference of type A&
6933
6934          --conversion of C to B is better than conversion of C to A,  */
6935       if (is_properly_derived_from (from, to_type1)
6936           && is_properly_derived_from (from, to_type2))
6937         {
6938           if (is_properly_derived_from (to_type1, to_type2))
6939             return 1;
6940           else if (is_properly_derived_from (to_type2, to_type1))
6941             return -1;
6942         }
6943     }
6944   else if (CLASS_TYPE_P (non_reference (to_type1))
6945            && same_type_p (to_type1, to_type2))
6946     {
6947       tree to = non_reference (to_type1);
6948
6949       /* [over.ics.rank]
6950
6951          --binding of an expression of type B to a reference of type
6952            A& is better than binding an expression of type C to a
6953            reference of type A&,
6954
6955          --conversion of B to A is better than conversion of C to A  */
6956       if (is_properly_derived_from (from_type1, to)
6957           && is_properly_derived_from (from_type2, to))
6958         {
6959           if (is_properly_derived_from (from_type2, from_type1))
6960             return 1;
6961           else if (is_properly_derived_from (from_type1, from_type2))
6962             return -1;
6963         }
6964     }
6965
6966   /* [over.ics.rank]
6967
6968      --S1 and S2 differ only in their qualification conversion and  yield
6969        similar  types  T1 and T2 (_conv.qual_), respectively, and the cv-
6970        qualification signature of type T1 is a proper subset of  the  cv-
6971        qualification signature of type T2  */
6972   if (ics1->kind == ck_qual
6973       && ics2->kind == ck_qual
6974       && same_type_p (from_type1, from_type2))
6975     {
6976       int result = comp_cv_qual_signature (to_type1, to_type2);
6977       if (result != 0)
6978         return result;
6979     }
6980
6981   /* [over.ics.rank]
6982
6983      --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
6984      to an implicit object parameter, and either S1 binds an lvalue reference
6985      to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
6986      reference to an rvalue and S2 binds an lvalue reference
6987      (C++0x draft standard, 13.3.3.2)
6988
6989      --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6990      types to which the references refer are the same type except for
6991      top-level cv-qualifiers, and the type to which the reference
6992      initialized by S2 refers is more cv-qualified than the type to
6993      which the reference initialized by S1 refers */
6994
6995   if (ref_conv1 && ref_conv2)
6996     {
6997       if (!ref_conv1->this_p && !ref_conv2->this_p
6998           && (TYPE_REF_IS_RVALUE (ref_conv1->type)
6999               != TYPE_REF_IS_RVALUE (ref_conv2->type)))
7000         {
7001           if (ref_conv1->rvaluedness_matches_p)
7002             return 1;
7003           if (ref_conv2->rvaluedness_matches_p)
7004             return -1;
7005         }
7006
7007       if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
7008         return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
7009                                       TREE_TYPE (ref_conv1->type));
7010     }
7011
7012   /* Neither conversion sequence is better than the other.  */
7013   return 0;
7014 }
7015
7016 /* The source type for this standard conversion sequence.  */
7017
7018 static tree
7019 source_type (conversion *t)
7020 {
7021   for (;; t = t->u.next)
7022     {
7023       if (t->kind == ck_user
7024           || t->kind == ck_ambig
7025           || t->kind == ck_identity)
7026         return t->type;
7027     }
7028   gcc_unreachable ();
7029 }
7030
7031 /* Note a warning about preferring WINNER to LOSER.  We do this by storing
7032    a pointer to LOSER and re-running joust to produce the warning if WINNER
7033    is actually used.  */
7034
7035 static void
7036 add_warning (struct z_candidate *winner, struct z_candidate *loser)
7037 {
7038   candidate_warning *cw = (candidate_warning *)
7039     conversion_obstack_alloc (sizeof (candidate_warning));
7040   cw->loser = loser;
7041   cw->next = winner->warnings;
7042   winner->warnings = cw;
7043 }
7044
7045 /* Compare two candidates for overloading as described in
7046    [over.match.best].  Return values:
7047
7048       1: cand1 is better than cand2
7049      -1: cand2 is better than cand1
7050       0: cand1 and cand2 are indistinguishable */
7051
7052 static int
7053 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
7054 {
7055   int winner = 0;
7056   int off1 = 0, off2 = 0;
7057   size_t i;
7058   size_t len;
7059
7060   /* Candidates that involve bad conversions are always worse than those
7061      that don't.  */
7062   if (cand1->viable > cand2->viable)
7063     return 1;
7064   if (cand1->viable < cand2->viable)
7065     return -1;
7066
7067   /* If we have two pseudo-candidates for conversions to the same type,
7068      or two candidates for the same function, arbitrarily pick one.  */
7069   if (cand1->fn == cand2->fn
7070       && (IS_TYPE_OR_DECL_P (cand1->fn)))
7071     return 1;
7072
7073   /* a viable function F1
7074      is defined to be a better function than another viable function F2  if
7075      for  all arguments i, ICSi(F1) is not a worse conversion sequence than
7076      ICSi(F2), and then */
7077
7078   /* for some argument j, ICSj(F1) is a better conversion  sequence  than
7079      ICSj(F2) */
7080
7081   /* For comparing static and non-static member functions, we ignore
7082      the implicit object parameter of the non-static function.  The
7083      standard says to pretend that the static function has an object
7084      parm, but that won't work with operator overloading.  */
7085   len = cand1->num_convs;
7086   if (len != cand2->num_convs)
7087     {
7088       int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
7089       int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
7090
7091       gcc_assert (static_1 != static_2);
7092
7093       if (static_1)
7094         off2 = 1;
7095       else
7096         {
7097           off1 = 1;
7098           --len;
7099         }
7100     }
7101
7102   for (i = 0; i < len; ++i)
7103     {
7104       conversion *t1 = cand1->convs[i + off1];
7105       conversion *t2 = cand2->convs[i + off2];
7106       int comp = compare_ics (t1, t2);
7107
7108       if (comp != 0)
7109         {
7110           if (warn_sign_promo
7111               && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
7112                   == cr_std + cr_promotion)
7113               && t1->kind == ck_std
7114               && t2->kind == ck_std
7115               && TREE_CODE (t1->type) == INTEGER_TYPE
7116               && TREE_CODE (t2->type) == INTEGER_TYPE
7117               && (TYPE_PRECISION (t1->type)
7118                   == TYPE_PRECISION (t2->type))
7119               && (TYPE_UNSIGNED (t1->u.next->type)
7120                   || (TREE_CODE (t1->u.next->type)
7121                       == ENUMERAL_TYPE)))
7122             {
7123               tree type = t1->u.next->type;
7124               tree type1, type2;
7125               struct z_candidate *w, *l;
7126               if (comp > 0)
7127                 type1 = t1->type, type2 = t2->type,
7128                   w = cand1, l = cand2;
7129               else
7130                 type1 = t2->type, type2 = t1->type,
7131                   w = cand2, l = cand1;
7132
7133               if (warn)
7134                 {
7135                   warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
7136                            type, type1, type2);
7137                   warning (OPT_Wsign_promo, "  in call to %qD", w->fn);
7138                 }
7139               else
7140                 add_warning (w, l);
7141             }
7142
7143           if (winner && comp != winner)
7144             {
7145               winner = 0;
7146               goto tweak;
7147             }
7148           winner = comp;
7149         }
7150     }
7151
7152   /* warn about confusing overload resolution for user-defined conversions,
7153      either between a constructor and a conversion op, or between two
7154      conversion ops.  */
7155   if (winner && warn_conversion && cand1->second_conv
7156       && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
7157       && winner != compare_ics (cand1->second_conv, cand2->second_conv))
7158     {
7159       struct z_candidate *w, *l;
7160       bool give_warning = false;
7161
7162       if (winner == 1)
7163         w = cand1, l = cand2;
7164       else
7165         w = cand2, l = cand1;
7166
7167       /* We don't want to complain about `X::operator T1 ()'
7168          beating `X::operator T2 () const', when T2 is a no less
7169          cv-qualified version of T1.  */
7170       if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
7171           && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
7172         {
7173           tree t = TREE_TYPE (TREE_TYPE (l->fn));
7174           tree f = TREE_TYPE (TREE_TYPE (w->fn));
7175
7176           if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
7177             {
7178               t = TREE_TYPE (t);
7179               f = TREE_TYPE (f);
7180             }
7181           if (!comp_ptr_ttypes (t, f))
7182             give_warning = true;
7183         }
7184       else
7185         give_warning = true;
7186
7187       if (!give_warning)
7188         /*NOP*/;
7189       else if (warn)
7190         {
7191           tree source = source_type (w->convs[0]);
7192           if (! DECL_CONSTRUCTOR_P (w->fn))
7193             source = TREE_TYPE (source);
7194           if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
7195               && warning (OPT_Wconversion, "  for conversion from %qT to %qT",
7196                           source, w->second_conv->type))
7197             {
7198               inform (input_location, "  because conversion sequence for the argument is better");
7199             }
7200         }
7201       else
7202         add_warning (w, l);
7203     }
7204
7205   if (winner)
7206     return winner;
7207
7208   /* or, if not that,
7209      F1 is a non-template function and F2 is a template function
7210      specialization.  */
7211
7212   if (!cand1->template_decl && cand2->template_decl)
7213     return 1;
7214   else if (cand1->template_decl && !cand2->template_decl)
7215     return -1;
7216
7217   /* or, if not that,
7218      F1 and F2 are template functions and the function template for F1 is
7219      more specialized than the template for F2 according to the partial
7220      ordering rules.  */
7221
7222   if (cand1->template_decl && cand2->template_decl)
7223     {
7224       winner = more_specialized_fn
7225         (TI_TEMPLATE (cand1->template_decl),
7226          TI_TEMPLATE (cand2->template_decl),
7227          /* [temp.func.order]: The presence of unused ellipsis and default
7228             arguments has no effect on the partial ordering of function
7229             templates.   add_function_candidate() will not have
7230             counted the "this" argument for constructors.  */
7231          cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
7232       if (winner)
7233         return winner;
7234     }
7235
7236   /* or, if not that,
7237      the  context  is  an  initialization by user-defined conversion (see
7238      _dcl.init_  and  _over.match.user_)  and  the  standard   conversion
7239      sequence  from  the return type of F1 to the destination type (i.e.,
7240      the type of the entity being initialized)  is  a  better  conversion
7241      sequence  than the standard conversion sequence from the return type
7242      of F2 to the destination type.  */
7243
7244   if (cand1->second_conv)
7245     {
7246       winner = compare_ics (cand1->second_conv, cand2->second_conv);
7247       if (winner)
7248         return winner;
7249     }
7250
7251   /* Check whether we can discard a builtin candidate, either because we
7252      have two identical ones or matching builtin and non-builtin candidates.
7253
7254      (Pedantically in the latter case the builtin which matched the user
7255      function should not be added to the overload set, but we spot it here.
7256
7257      [over.match.oper]
7258      ... the builtin candidates include ...
7259      - do not have the same parameter type list as any non-template
7260        non-member candidate.  */
7261
7262   if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
7263       || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
7264     {
7265       for (i = 0; i < len; ++i)
7266         if (!same_type_p (cand1->convs[i]->type,
7267                           cand2->convs[i]->type))
7268           break;
7269       if (i == cand1->num_convs)
7270         {
7271           if (cand1->fn == cand2->fn)
7272             /* Two built-in candidates; arbitrarily pick one.  */
7273             return 1;
7274           else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
7275             /* cand1 is built-in; prefer cand2.  */
7276             return -1;
7277           else
7278             /* cand2 is built-in; prefer cand1.  */
7279             return 1;
7280         }
7281     }
7282
7283   /* If the two function declarations represent the same function (this can
7284      happen with declarations in multiple scopes and arg-dependent lookup),
7285      arbitrarily choose one.  But first make sure the default args we're
7286      using match.  */
7287   if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
7288       && equal_functions (cand1->fn, cand2->fn))
7289     {
7290       tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
7291       tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
7292
7293       gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
7294
7295       for (i = 0; i < len; ++i)
7296         {
7297           /* Don't crash if the fn is variadic.  */
7298           if (!parms1)
7299             break;
7300           parms1 = TREE_CHAIN (parms1);
7301           parms2 = TREE_CHAIN (parms2);
7302         }
7303
7304       if (off1)
7305         parms1 = TREE_CHAIN (parms1);
7306       else if (off2)
7307         parms2 = TREE_CHAIN (parms2);
7308
7309       for (; parms1; ++i)
7310         {
7311           if (!cp_tree_equal (TREE_PURPOSE (parms1),
7312                               TREE_PURPOSE (parms2)))
7313             {
7314               if (warn)
7315                 {
7316                   permerror (input_location, "default argument mismatch in "
7317                              "overload resolution");
7318                   inform (input_location,
7319                           " candidate 1: %q+#F", cand1->fn);
7320                   inform (input_location,
7321                           " candidate 2: %q+#F", cand2->fn);
7322                 }
7323               else
7324                 add_warning (cand1, cand2);
7325               break;
7326             }
7327           parms1 = TREE_CHAIN (parms1);
7328           parms2 = TREE_CHAIN (parms2);
7329         }
7330
7331       return 1;
7332     }
7333
7334 tweak:
7335
7336   /* Extension: If the worst conversion for one candidate is worse than the
7337      worst conversion for the other, take the first.  */
7338   if (!pedantic)
7339     {
7340       conversion_rank rank1 = cr_identity, rank2 = cr_identity;
7341       struct z_candidate *w = 0, *l = 0;
7342
7343       for (i = 0; i < len; ++i)
7344         {
7345           if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
7346             rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
7347           if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
7348             rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
7349         }
7350       if (rank1 < rank2)
7351         winner = 1, w = cand1, l = cand2;
7352       if (rank1 > rank2)
7353         winner = -1, w = cand2, l = cand1;
7354       if (winner)
7355         {
7356           if (warn)
7357             {
7358               pedwarn (input_location, 0,
7359               "ISO C++ says that these are ambiguous, even "
7360               "though the worst conversion for the first is better than "
7361               "the worst conversion for the second:");
7362               print_z_candidate (_("candidate 1:"), w);
7363               print_z_candidate (_("candidate 2:"), l);
7364             }
7365           else
7366             add_warning (w, l);
7367           return winner;
7368         }
7369     }
7370
7371   gcc_assert (!winner);
7372   return 0;
7373 }
7374
7375 /* Given a list of candidates for overloading, find the best one, if any.
7376    This algorithm has a worst case of O(2n) (winner is last), and a best
7377    case of O(n/2) (totally ambiguous); much better than a sorting
7378    algorithm.  */
7379
7380 static struct z_candidate *
7381 tourney (struct z_candidate *candidates)
7382 {
7383   struct z_candidate *champ = candidates, *challenger;
7384   int fate;
7385   int champ_compared_to_predecessor = 0;
7386
7387   /* Walk through the list once, comparing each current champ to the next
7388      candidate, knocking out a candidate or two with each comparison.  */
7389
7390   for (challenger = champ->next; challenger; )
7391     {
7392       fate = joust (champ, challenger, 0);
7393       if (fate == 1)
7394         challenger = challenger->next;
7395       else
7396         {
7397           if (fate == 0)
7398             {
7399               champ = challenger->next;
7400               if (champ == 0)
7401                 return NULL;
7402               champ_compared_to_predecessor = 0;
7403             }
7404           else
7405             {
7406               champ = challenger;
7407               champ_compared_to_predecessor = 1;
7408             }
7409
7410           challenger = champ->next;
7411         }
7412     }
7413
7414   /* Make sure the champ is better than all the candidates it hasn't yet
7415      been compared to.  */
7416
7417   for (challenger = candidates;
7418        challenger != champ
7419          && !(champ_compared_to_predecessor && challenger->next == champ);
7420        challenger = challenger->next)
7421     {
7422       fate = joust (champ, challenger, 0);
7423       if (fate != 1)
7424         return NULL;
7425     }
7426
7427   return champ;
7428 }
7429
7430 /* Returns nonzero if things of type FROM can be converted to TO.  */
7431
7432 bool
7433 can_convert (tree to, tree from)
7434 {
7435   return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT);
7436 }
7437
7438 /* Returns nonzero if ARG (of type FROM) can be converted to TO.  */
7439
7440 bool
7441 can_convert_arg (tree to, tree from, tree arg, int flags)
7442 {
7443   conversion *t;
7444   void *p;
7445   bool ok_p;
7446
7447   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7448   p = conversion_obstack_alloc (0);
7449
7450   t  = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7451                             flags);
7452   ok_p = (t && !t->bad_p);
7453
7454   /* Free all the conversions we allocated.  */
7455   obstack_free (&conversion_obstack, p);
7456
7457   return ok_p;
7458 }
7459
7460 /* Like can_convert_arg, but allows dubious conversions as well.  */
7461
7462 bool
7463 can_convert_arg_bad (tree to, tree from, tree arg, int flags)
7464 {
7465   conversion *t;
7466   void *p;
7467
7468   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7469   p = conversion_obstack_alloc (0);
7470   /* Try to perform the conversion.  */
7471   t  = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7472                             flags);
7473   /* Free all the conversions we allocated.  */
7474   obstack_free (&conversion_obstack, p);
7475
7476   return t != NULL;
7477 }
7478
7479 /* Convert EXPR to TYPE.  Return the converted expression.
7480
7481    Note that we allow bad conversions here because by the time we get to
7482    this point we are committed to doing the conversion.  If we end up
7483    doing a bad conversion, convert_like will complain.  */
7484
7485 tree
7486 perform_implicit_conversion_flags (tree type, tree expr, tsubst_flags_t complain, int flags)
7487 {
7488   conversion *conv;
7489   void *p;
7490
7491   if (error_operand_p (expr))
7492     return error_mark_node;
7493
7494   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7495   p = conversion_obstack_alloc (0);
7496
7497   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7498                               /*c_cast_p=*/false,
7499                               flags);
7500
7501   if (!conv)
7502     {
7503       if (complain & tf_error)
7504         {
7505           /* If expr has unknown type, then it is an overloaded function.
7506              Call instantiate_type to get good error messages.  */
7507           if (TREE_TYPE (expr) == unknown_type_node)
7508             instantiate_type (type, expr, complain);
7509           else if (invalid_nonstatic_memfn_p (expr, complain))
7510             /* We gave an error.  */;
7511           else
7512             error ("could not convert %qE to %qT", expr, type);
7513         }
7514       expr = error_mark_node;
7515     }
7516   else if (processing_template_decl)
7517     {
7518       /* In a template, we are only concerned about determining the
7519          type of non-dependent expressions, so we do not have to
7520          perform the actual conversion.  */
7521       if (TREE_TYPE (expr) != type)
7522         expr = build_nop (type, expr);
7523     }
7524   else
7525     expr = convert_like (conv, expr, complain);
7526
7527   /* Free all the conversions we allocated.  */
7528   obstack_free (&conversion_obstack, p);
7529
7530   return expr;
7531 }
7532
7533 tree
7534 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
7535 {
7536   return perform_implicit_conversion_flags (type, expr, complain, LOOKUP_IMPLICIT);
7537 }
7538
7539 /* Convert EXPR to TYPE (as a direct-initialization) if that is
7540    permitted.  If the conversion is valid, the converted expression is
7541    returned.  Otherwise, NULL_TREE is returned, except in the case
7542    that TYPE is a class type; in that case, an error is issued.  If
7543    C_CAST_P is true, then this direction initialization is taking
7544    place as part of a static_cast being attempted as part of a C-style
7545    cast.  */
7546
7547 tree
7548 perform_direct_initialization_if_possible (tree type,
7549                                            tree expr,
7550                                            bool c_cast_p,
7551                                            tsubst_flags_t complain)
7552 {
7553   conversion *conv;
7554   void *p;
7555
7556   if (type == error_mark_node || error_operand_p (expr))
7557     return error_mark_node;
7558   /* [dcl.init]
7559
7560      If the destination type is a (possibly cv-qualified) class type:
7561
7562      -- If the initialization is direct-initialization ...,
7563      constructors are considered. ... If no constructor applies, or
7564      the overload resolution is ambiguous, the initialization is
7565      ill-formed.  */
7566   if (CLASS_TYPE_P (type))
7567     {
7568       VEC(tree,gc) *args = make_tree_vector_single (expr);
7569       expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
7570                                         &args, type, LOOKUP_NORMAL, complain);
7571       release_tree_vector (args);
7572       return build_cplus_new (type, expr);
7573     }
7574
7575   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7576   p = conversion_obstack_alloc (0);
7577
7578   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7579                               c_cast_p,
7580                               LOOKUP_NORMAL);
7581   if (!conv || conv->bad_p)
7582     expr = NULL_TREE;
7583   else
7584     expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
7585                               /*issue_conversion_warnings=*/false,
7586                               c_cast_p,
7587                               tf_warning_or_error);
7588
7589   /* Free all the conversions we allocated.  */
7590   obstack_free (&conversion_obstack, p);
7591
7592   return expr;
7593 }
7594
7595 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE.  The reference
7596    is being bound to a temporary.  Create and return a new VAR_DECL
7597    with the indicated TYPE; this variable will store the value to
7598    which the reference is bound.  */
7599
7600 tree
7601 make_temporary_var_for_ref_to_temp (tree decl, tree type)
7602 {
7603   tree var;
7604
7605   /* Create the variable.  */
7606   var = create_temporary_var (type);
7607
7608   /* Register the variable.  */
7609   if (TREE_STATIC (decl))
7610     {
7611       /* Namespace-scope or local static; give it a mangled name.  */
7612       tree name;
7613
7614       TREE_STATIC (var) = 1;
7615       name = mangle_ref_init_variable (decl);
7616       DECL_NAME (var) = name;
7617       SET_DECL_ASSEMBLER_NAME (var, name);
7618       var = pushdecl_top_level (var);
7619     }
7620   else
7621     /* Create a new cleanup level if necessary.  */
7622     maybe_push_cleanup_level (type);
7623
7624   return var;
7625 }
7626
7627 /* EXPR is the initializer for a variable DECL of reference or
7628    std::initializer_list type.  Create, push and return a new VAR_DECL
7629    for the initializer so that it will live as long as DECL.  Any
7630    cleanup for the new variable is returned through CLEANUP, and the
7631    code to initialize the new variable is returned through INITP.  */
7632
7633 tree
7634 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
7635 {
7636   tree init;
7637   tree type;
7638   tree var;
7639
7640   /* Create the temporary variable.  */
7641   type = TREE_TYPE (expr);
7642   var = make_temporary_var_for_ref_to_temp (decl, type);
7643   layout_decl (var, 0);
7644   /* If the rvalue is the result of a function call it will be
7645      a TARGET_EXPR.  If it is some other construct (such as a
7646      member access expression where the underlying object is
7647      itself the result of a function call), turn it into a
7648      TARGET_EXPR here.  It is important that EXPR be a
7649      TARGET_EXPR below since otherwise the INIT_EXPR will
7650      attempt to make a bitwise copy of EXPR to initialize
7651      VAR.  */
7652   if (TREE_CODE (expr) != TARGET_EXPR)
7653     expr = get_target_expr (expr);
7654   /* Create the INIT_EXPR that will initialize the temporary
7655      variable.  */
7656   init = build2 (INIT_EXPR, type, var, expr);
7657   if (at_function_scope_p ())
7658     {
7659       add_decl_expr (var);
7660
7661       if (TREE_STATIC (var))
7662         init = add_stmt_to_compound (init, register_dtor_fn (var));
7663       else
7664         *cleanup = cxx_maybe_build_cleanup (var);
7665
7666       /* We must be careful to destroy the temporary only
7667          after its initialization has taken place.  If the
7668          initialization throws an exception, then the
7669          destructor should not be run.  We cannot simply
7670          transform INIT into something like:
7671
7672          (INIT, ({ CLEANUP_STMT; }))
7673
7674          because emit_local_var always treats the
7675          initializer as a full-expression.  Thus, the
7676          destructor would run too early; it would run at the
7677          end of initializing the reference variable, rather
7678          than at the end of the block enclosing the
7679          reference variable.
7680
7681          The solution is to pass back a cleanup expression
7682          which the caller is responsible for attaching to
7683          the statement tree.  */
7684     }
7685   else
7686     {
7687       rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
7688       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7689         static_aggregates = tree_cons (NULL_TREE, var,
7690                                        static_aggregates);
7691     }
7692
7693   *initp = init;
7694   return var;
7695 }
7696
7697 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
7698    initializing a variable of that TYPE.  If DECL is non-NULL, it is
7699    the VAR_DECL being initialized with the EXPR.  (In that case, the
7700    type of DECL will be TYPE.)  If DECL is non-NULL, then CLEANUP must
7701    also be non-NULL, and with *CLEANUP initialized to NULL.  Upon
7702    return, if *CLEANUP is no longer NULL, it will be an expression
7703    that should be pushed as a cleanup after the returned expression
7704    is used to initialize DECL.
7705
7706    Return the converted expression.  */
7707
7708 tree
7709 initialize_reference (tree type, tree expr, tree decl, tree *cleanup,
7710                       tsubst_flags_t complain)
7711 {
7712   conversion *conv;
7713   void *p;
7714
7715   if (type == error_mark_node || error_operand_p (expr))
7716     return error_mark_node;
7717
7718   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7719   p = conversion_obstack_alloc (0);
7720
7721   conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
7722                             LOOKUP_NORMAL);
7723   if (!conv || conv->bad_p)
7724     {
7725       if (complain & tf_error)
7726         {
7727           if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
7728               && !TYPE_REF_IS_RVALUE (type)
7729               && !real_lvalue_p (expr))
7730             error ("invalid initialization of non-const reference of "
7731                    "type %qT from an rvalue of type %qT",
7732                    type, TREE_TYPE (expr));
7733           else
7734             error ("invalid initialization of reference of type "
7735                    "%qT from expression of type %qT", type,
7736                    TREE_TYPE (expr));
7737         }
7738       return error_mark_node;
7739     }
7740
7741   /* If DECL is non-NULL, then this special rule applies:
7742
7743        [class.temporary]
7744
7745        The temporary to which the reference is bound or the temporary
7746        that is the complete object to which the reference is bound
7747        persists for the lifetime of the reference.
7748
7749        The temporaries created during the evaluation of the expression
7750        initializing the reference, except the temporary to which the
7751        reference is bound, are destroyed at the end of the
7752        full-expression in which they are created.
7753
7754      In that case, we store the converted expression into a new
7755      VAR_DECL in a new scope.
7756
7757      However, we want to be careful not to create temporaries when
7758      they are not required.  For example, given:
7759
7760        struct B {};
7761        struct D : public B {};
7762        D f();
7763        const B& b = f();
7764
7765      there is no need to copy the return value from "f"; we can just
7766      extend its lifetime.  Similarly, given:
7767
7768        struct S {};
7769        struct T { operator S(); };
7770        T t;
7771        const S& s = t;
7772
7773     we can extend the lifetime of the return value of the conversion
7774     operator.  */
7775   gcc_assert (conv->kind == ck_ref_bind);
7776   if (decl)
7777     {
7778       tree var;
7779       tree base_conv_type;
7780
7781       /* Skip over the REF_BIND.  */
7782       conv = conv->u.next;
7783       /* If the next conversion is a BASE_CONV, skip that too -- but
7784          remember that the conversion was required.  */
7785       if (conv->kind == ck_base)
7786         {
7787           base_conv_type = conv->type;
7788           conv = conv->u.next;
7789         }
7790       else
7791         base_conv_type = NULL_TREE;
7792       /* Perform the remainder of the conversion.  */
7793       expr = convert_like_real (conv, expr,
7794                                 /*fn=*/NULL_TREE, /*argnum=*/0,
7795                                 /*inner=*/-1,
7796                                 /*issue_conversion_warnings=*/true,
7797                                 /*c_cast_p=*/false,
7798                                 tf_warning_or_error);
7799       if (error_operand_p (expr))
7800         expr = error_mark_node;
7801       else
7802         {
7803           if (!lvalue_or_rvalue_with_address_p (expr))
7804             {
7805               tree init;
7806               var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
7807               /* Use its address to initialize the reference variable.  */
7808               expr = build_address (var);
7809               if (base_conv_type)
7810                 expr = convert_to_base (expr,
7811                                         build_pointer_type (base_conv_type),
7812                                         /*check_access=*/true,
7813                                         /*nonnull=*/true);
7814               expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
7815             }
7816           else
7817             /* Take the address of EXPR.  */
7818             expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
7819           /* If a BASE_CONV was required, perform it now.  */
7820           if (base_conv_type)
7821             expr = (perform_implicit_conversion
7822                     (build_pointer_type (base_conv_type), expr,
7823                      tf_warning_or_error));
7824           expr = build_nop (type, expr);
7825         }
7826     }
7827   else
7828     /* Perform the conversion.  */
7829     expr = convert_like (conv, expr, tf_warning_or_error);
7830
7831   /* Free all the conversions we allocated.  */
7832   obstack_free (&conversion_obstack, p);
7833
7834   return expr;
7835 }
7836
7837 /* Returns true iff TYPE is some variant of std::initializer_list.  */
7838
7839 bool
7840 is_std_init_list (tree type)
7841 {
7842   return (CLASS_TYPE_P (type)
7843           && CP_TYPE_CONTEXT (type) == std_node
7844           && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
7845 }
7846
7847 /* Returns true iff DECL is a list constructor: i.e. a constructor which
7848    will accept an argument list of a single std::initializer_list<T>.  */
7849
7850 bool
7851 is_list_ctor (tree decl)
7852 {
7853   tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
7854   tree arg;
7855
7856   if (!args || args == void_list_node)
7857     return false;
7858
7859   arg = non_reference (TREE_VALUE (args));
7860   if (!is_std_init_list (arg))
7861     return false;
7862
7863   args = TREE_CHAIN (args);
7864
7865   if (args && args != void_list_node && !TREE_PURPOSE (args))
7866     /* There are more non-defaulted parms.  */
7867     return false;
7868
7869   return true;
7870 }
7871
7872 #include "gt-cp-call.h"