gcc/cp/call.c

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