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