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