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