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