gcc/cp/call.c

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