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