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