gcc/cp/call.c

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