gcc/cp/call.c

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