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