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