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