gcc/cp/call.c

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