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   if (NULLPTR_TYPE_P (TREE_TYPE (t)))
 470     return true;
 471   if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)))
 472     {
 473       if (cxx_dialect >= cxx0x)
 474         {
 475           t = fold_non_dependent_expr (t);
 476           t = maybe_constant_value (t);
 477           if (TREE_CONSTANT (t) && integer_zerop (t))
 478             return true;
 479         }
 480       else
 481         {
 482           t = integral_constant_value (t);
 483           STRIP_NOPS (t);
 484           if (integer_zerop (t) && !TREE_OVERFLOW (t))
 485             return true;
 486         }
 487     }
 488   return false;
 489 }
 490
 491 /* Returns nonzero if PARMLIST consists of only default parms and/or
 492    ellipsis.  */
 493
 494 bool
 495 sufficient_parms_p (const_tree parmlist)
 496 {
 497   for (; parmlist && parmlist != void_list_node;
 498        parmlist = TREE_CHAIN (parmlist))
 499     if (!TREE_PURPOSE (parmlist))
 500       return false;
 501   return true;
 502 }
 503
 504 /* Allocate N bytes of memory from the conversion obstack.  The memory
 505    is zeroed before being returned.  */
 506
 507 static void *
 508 conversion_obstack_alloc (size_t n)
 509 {
 510   void *p;
 511   if (!conversion_obstack_initialized)
 512     {
 513       gcc_obstack_init (&conversion_obstack);
 514       conversion_obstack_initialized = true;
 515     }
 516   p = obstack_alloc (&conversion_obstack, n);
 517   memset (p, 0, n);
 518   return p;
 519 }
 520
 521 /* Dynamically allocate a conversion.  */
 522
 523 static conversion *
 524 alloc_conversion (conversion_kind kind)
 525 {
 526   conversion *c;
 527   c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
 528   c->kind = kind;
 529   return c;
 530 }
 531
 532 #ifdef ENABLE_CHECKING
 533
 534 /* Make sure that all memory on the conversion obstack has been
 535    freed.  */
 536
 537 void
 538 validate_conversion_obstack (void)
 539 {
 540   if (conversion_obstack_initialized)
 541     gcc_assert ((obstack_next_free (&conversion_obstack)
 542                  == obstack_base (&conversion_obstack)));
 543 }
 544
 545 #endif /* ENABLE_CHECKING */
 546
 547 /* Dynamically allocate an array of N conversions.  */
 548
 549 static conversion **
 550 alloc_conversions (size_t n)
 551 {
 552   return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
 553 }
 554
 555 static conversion *
 556 build_conv (conversion_kind code, tree type, conversion *from)
 557 {
 558   conversion *t;
 559   conversion_rank rank = CONVERSION_RANK (from);
 560
 561   /* Note that the caller is responsible for filling in t->cand for
 562      user-defined conversions.  */
 563   t = alloc_conversion (code);
 564   t->type = type;
 565   t->u.next = from;
 566
 567   switch (code)
 568     {
 569     case ck_ptr:
 570     case ck_pmem:
 571     case ck_base:
 572     case ck_std:
 573       if (rank < cr_std)
 574         rank = cr_std;
 575       break;
 576
 577     case ck_qual:
 578       if (rank < cr_exact)
 579         rank = cr_exact;
 580       break;
 581
 582     default:
 583       break;
 584     }
 585   t->rank = rank;
 586   t->user_conv_p = (code == ck_user || from->user_conv_p);
 587   t->bad_p = from->bad_p;
 588   t->base_p = false;
 589   return t;
 590 }
 591
 592 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
 593    specialization of std::initializer_list<T>, if such a conversion is
 594    possible.  */
 595
 596 static conversion *
 597 build_list_conv (tree type, tree ctor, int flags)
 598 {
 599   tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);
 600   unsigned len = CONSTRUCTOR_NELTS (ctor);
 601   conversion **subconvs = alloc_conversions (len);
 602   conversion *t;
 603   unsigned i;
 604   tree val;
 605
 606   /* Within a list-initialization we can have more user-defined
 607      conversions.  */
 608   flags &= ~LOOKUP_NO_CONVERSION;
 609   /* But no narrowing conversions.  */
 610   flags |= LOOKUP_NO_NARROWING;
 611
 612   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
 613     {
 614       conversion *sub
 615         = implicit_conversion (elttype, TREE_TYPE (val), val,
 616                                false, flags);
 617       if (sub == NULL)
 618         return NULL;
 619
 620       subconvs[i] = sub;
 621     }
 622
 623   t = alloc_conversion (ck_list);
 624   t->type = type;
 625   t->u.list = subconvs;
 626   t->rank = cr_exact;
 627
 628   for (i = 0; i < len; ++i)
 629     {
 630       conversion *sub = subconvs[i];
 631       if (sub->rank > t->rank)
 632         t->rank = sub->rank;
 633       if (sub->user_conv_p)
 634         t->user_conv_p = true;
 635       if (sub->bad_p)
 636         t->bad_p = true;
 637     }
 638
 639   return t;
 640 }
 641
 642 /* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list,
 643    is a valid aggregate initializer for array type ATYPE.  */
 644
 645 static bool
 646 can_convert_array (tree atype, tree ctor, int flags)
 647 {
 648   unsigned i;
 649   tree elttype = TREE_TYPE (atype);
 650   for (i = 0; i < CONSTRUCTOR_NELTS (ctor); ++i)
 651     {
 652       tree val = CONSTRUCTOR_ELT (ctor, i)->value;
 653       bool ok;
 654       if (TREE_CODE (elttype) == ARRAY_TYPE
 655           && TREE_CODE (val) == CONSTRUCTOR)
 656         ok = can_convert_array (elttype, val, flags);
 657       else
 658         ok = can_convert_arg (elttype, TREE_TYPE (val), val, flags);
 659       if (!ok)
 660         return false;
 661     }
 662   return true;
 663 }
 664
 665 /* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
 666    aggregate class, if such a conversion is possible.  */
 667
 668 static conversion *
 669 build_aggr_conv (tree type, tree ctor, int flags)
 670 {
 671   unsigned HOST_WIDE_INT i = 0;
 672   conversion *c;
 673   tree field = next_initializable_field (TYPE_FIELDS (type));
 674   tree empty_ctor = NULL_TREE;
 675
 676   for (; field; field = next_initializable_field (DECL_CHAIN (field)))
 677     {
 678       tree ftype = TREE_TYPE (field);
 679       tree val;
 680       bool ok;
 681
 682       if (i < CONSTRUCTOR_NELTS (ctor))
 683         val = CONSTRUCTOR_ELT (ctor, i)->value;
 684       else
 685         {
 686           if (empty_ctor == NULL_TREE)
 687             empty_ctor = build_constructor (init_list_type_node, NULL);
 688           val = empty_ctor;
 689         }
 690       ++i;
 691
 692       if (TREE_CODE (ftype) == ARRAY_TYPE
 693           && TREE_CODE (val) == CONSTRUCTOR)
 694         ok = can_convert_array (ftype, val, flags);
 695       else
 696         ok = can_convert_arg (ftype, TREE_TYPE (val), val, flags);
 697
 698       if (!ok)
 699         return NULL;
 700
 701       if (TREE_CODE (type) == UNION_TYPE)
 702         break;
 703     }
 704
 705   if (i < CONSTRUCTOR_NELTS (ctor))
 706     return NULL;
 707
 708   c = alloc_conversion (ck_aggr);
 709   c->type = type;
 710   c->rank = cr_exact;
 711   c->user_conv_p = true;
 712   c->u.next = NULL;
 713   return c;
 714 }
 715
 716 /* Build a representation of the identity conversion from EXPR to
 717    itself.  The TYPE should match the type of EXPR, if EXPR is non-NULL.  */
 718
 719 static conversion *
 720 build_identity_conv (tree type, tree expr)
 721 {
 722   conversion *c;
 723
 724   c = alloc_conversion (ck_identity);
 725   c->type = type;
 726   c->u.expr = expr;
 727
 728   return c;
 729 }
 730
 731 /* Converting from EXPR to TYPE was ambiguous in the sense that there
 732    were multiple user-defined conversions to accomplish the job.
 733    Build a conversion that indicates that ambiguity.  */
 734
 735 static conversion *
 736 build_ambiguous_conv (tree type, tree expr)
 737 {
 738   conversion *c;
 739
 740   c = alloc_conversion (ck_ambig);
 741   c->type = type;
 742   c->u.expr = expr;
 743
 744   return c;
 745 }
 746
 747 tree
 748 strip_top_quals (tree t)
 749 {
 750   if (TREE_CODE (t) == ARRAY_TYPE)
 751     return t;
 752   return cp_build_qualified_type (t, 0);
 753 }
 754
 755 /* Returns the standard conversion path (see [conv]) from type FROM to type
 756    TO, if any.  For proper handling of null pointer constants, you must
 757    also pass the expression EXPR to convert from.  If C_CAST_P is true,
 758    this conversion is coming from a C-style cast.  */
 759
 760 static conversion *
 761 standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
 762                      int flags)
 763 {
 764   enum tree_code fcode, tcode;
 765   conversion *conv;
 766   bool fromref = false;
 767
 768   to = non_reference (to);
 769   if (TREE_CODE (from) == REFERENCE_TYPE)
 770     {
 771       fromref = true;
 772       from = TREE_TYPE (from);
 773     }
 774   to = strip_top_quals (to);
 775   from = strip_top_quals (from);
 776
 777   if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
 778       && expr && type_unknown_p (expr))
 779     {
 780       tsubst_flags_t tflags = tf_conv;
 781       if (!(flags & LOOKUP_PROTECT))
 782         tflags |= tf_no_access_control;
 783       expr = instantiate_type (to, expr, tflags);
 784       if (expr == error_mark_node)
 785         return NULL;
 786       from = TREE_TYPE (expr);
 787     }
 788
 789   fcode = TREE_CODE (from);
 790   tcode = TREE_CODE (to);
 791
 792   conv = build_identity_conv (from, expr);
 793   if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
 794     {
 795       from = type_decays_to (from);
 796       fcode = TREE_CODE (from);
 797       conv = build_conv (ck_lvalue, from, conv);
 798     }
 799   else if (fromref || (expr && lvalue_p (expr)))
 800     {
 801       if (expr)
 802         {
 803           tree bitfield_type;
 804           bitfield_type = is_bitfield_expr_with_lowered_type (expr);
 805           if (bitfield_type)
 806             {
 807               from = strip_top_quals (bitfield_type);
 808               fcode = TREE_CODE (from);
 809             }
 810         }
 811       conv = build_conv (ck_rvalue, from, conv);
 812     }
 813
 814    /* Allow conversion between `__complex__' data types.  */
 815   if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
 816     {
 817       /* The standard conversion sequence to convert FROM to TO is
 818          the standard conversion sequence to perform componentwise
 819          conversion.  */
 820       conversion *part_conv = standard_conversion
 821         (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
 822
 823       if (part_conv)
 824         {
 825           conv = build_conv (part_conv->kind, to, conv);
 826           conv->rank = part_conv->rank;
 827         }
 828       else
 829         conv = NULL;
 830
 831       return conv;
 832     }
 833
 834   if (same_type_p (from, to))
 835     return conv;
 836
 837   /* [conv.ptr]
 838      A null pointer constant can be converted to a pointer type; ... A
 839      null pointer constant of integral type can be converted to an
 840      rvalue of type std::nullptr_t. */
 841   if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to)
 842        || NULLPTR_TYPE_P (to))
 843       && expr && null_ptr_cst_p (expr))
 844     conv = build_conv (ck_std, to, conv);
 845   else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
 846            || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
 847     {
 848       /* For backwards brain damage compatibility, allow interconversion of
 849          pointers and integers with a pedwarn.  */
 850       conv = build_conv (ck_std, to, conv);
 851       conv->bad_p = true;
 852     }
 853   else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
 854     {
 855       /* For backwards brain damage compatibility, allow interconversion of
 856          enums and integers with a pedwarn.  */
 857       conv = build_conv (ck_std, to, conv);
 858       conv->bad_p = true;
 859     }
 860   else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
 861            || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
 862     {
 863       tree to_pointee;
 864       tree from_pointee;
 865
 866       if (tcode == POINTER_TYPE
 867           && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
 868                                                         TREE_TYPE (to)))
 869         ;
 870       else if (VOID_TYPE_P (TREE_TYPE (to))
 871                && !TYPE_PTRMEM_P (from)
 872                && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
 873         {
 874           tree nfrom = TREE_TYPE (from);
 875           if (c_dialect_objc ())
 876             nfrom = objc_non_volatilized_type (nfrom);
 877           from = build_pointer_type
 878             (cp_build_qualified_type (void_type_node,
 879                                       cp_type_quals (nfrom)));
 880           conv = build_conv (ck_ptr, from, conv);
 881         }
 882       else if (TYPE_PTRMEM_P (from))
 883         {
 884           tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
 885           tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
 886
 887           if (DERIVED_FROM_P (fbase, tbase)
 888               && (same_type_ignoring_top_level_qualifiers_p
 889                   (TYPE_PTRMEM_POINTED_TO_TYPE (from),
 890                    TYPE_PTRMEM_POINTED_TO_TYPE (to))))
 891             {
 892               from = build_ptrmem_type (tbase,
 893                                         TYPE_PTRMEM_POINTED_TO_TYPE (from));
 894               conv = build_conv (ck_pmem, from, conv);
 895             }
 896           else if (!same_type_p (fbase, tbase))
 897             return NULL;
 898         }
 899       else if (CLASS_TYPE_P (TREE_TYPE (from))
 900                && CLASS_TYPE_P (TREE_TYPE (to))
 901                /* [conv.ptr]
 902
 903                   An rvalue of type "pointer to cv D," where D is a
 904                   class type, can be converted to an rvalue of type
 905                   "pointer to cv B," where B is a base class (clause
 906                   _class.derived_) of D.  If B is an inaccessible
 907                   (clause _class.access_) or ambiguous
 908                   (_class.member.lookup_) base class of D, a program
 909                   that necessitates this conversion is ill-formed.
 910                   Therefore, we use DERIVED_FROM_P, and do not check
 911                   access or uniqueness.  */
 912                && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from)))
 913         {
 914           from =
 915             cp_build_qualified_type (TREE_TYPE (to),
 916                                      cp_type_quals (TREE_TYPE (from)));
 917           from = build_pointer_type (from);
 918           conv = build_conv (ck_ptr, from, conv);
 919           conv->base_p = true;
 920         }
 921
 922       if (tcode == POINTER_TYPE)
 923         {
 924           to_pointee = TREE_TYPE (to);
 925           from_pointee = TREE_TYPE (from);
 926         }
 927       else
 928         {
 929           to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
 930           from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
 931         }
 932
 933       if (same_type_p (from, to))
 934         /* OK */;
 935       else if (c_cast_p && comp_ptr_ttypes_const (to, from))
 936         /* In a C-style cast, we ignore CV-qualification because we
 937            are allowed to perform a static_cast followed by a
 938            const_cast.  */
 939         conv = build_conv (ck_qual, to, conv);
 940       else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
 941         conv = build_conv (ck_qual, to, conv);
 942       else if (expr && string_conv_p (to, expr, 0))
 943         /* converting from string constant to char *.  */
 944         conv = build_conv (ck_qual, to, conv);
 945       /* Allow conversions among compatible ObjC pointer types (base
 946          conversions have been already handled above).  */
 947       else if (c_dialect_objc ()
 948                && objc_compare_types (to, from, -4, NULL_TREE))
 949         conv = build_conv (ck_ptr, to, conv);
 950       else if (ptr_reasonably_similar (to_pointee, from_pointee))
 951         {
 952           conv = build_conv (ck_ptr, to, conv);
 953           conv->bad_p = true;
 954         }
 955       else
 956         return NULL;
 957
 958       from = to;
 959     }
 960   else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
 961     {
 962       tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
 963       tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
 964       tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
 965       tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
 966
 967       if (!DERIVED_FROM_P (fbase, tbase)
 968           || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
 969           || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
 970                          TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
 971           || cp_type_quals (fbase) != cp_type_quals (tbase))
 972         return NULL;
 973
 974       from = build_memfn_type (fromfn, tbase, cp_type_quals (tbase));
 975       from = build_ptrmemfunc_type (build_pointer_type (from));
 976       conv = build_conv (ck_pmem, from, conv);
 977       conv->base_p = true;
 978     }
 979   else if (tcode == BOOLEAN_TYPE)
 980     {
 981       /* [conv.bool]
 982
 983           An rvalue of arithmetic, unscoped enumeration, pointer, or
 984           pointer to member type can be converted to an rvalue of type
 985           bool. ... An rvalue of type std::nullptr_t can be converted
 986           to an rvalue of type bool;  */
 987       if (ARITHMETIC_TYPE_P (from)
 988           || UNSCOPED_ENUM_P (from)
 989           || fcode == POINTER_TYPE
 990           || TYPE_PTR_TO_MEMBER_P (from)
 991           || NULLPTR_TYPE_P (from))
 992         {
 993           conv = build_conv (ck_std, to, conv);
 994           if (fcode == POINTER_TYPE
 995               || TYPE_PTRMEM_P (from)
 996               || (TYPE_PTRMEMFUNC_P (from)
 997                   && conv->rank < cr_pbool)
 998               || NULLPTR_TYPE_P (from))
 999             conv->rank = cr_pbool;
1000           return conv;
1001         }
1002
1003       return NULL;
1004     }
1005   /* We don't check for ENUMERAL_TYPE here because there are no standard
1006      conversions to enum type.  */
1007   /* As an extension, allow conversion to complex type.  */
1008   else if (ARITHMETIC_TYPE_P (to))
1009     {
1010       if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE)
1011           || SCOPED_ENUM_P (from))
1012         return NULL;
1013       conv = build_conv (ck_std, to, conv);
1014
1015       /* Give this a better rank if it's a promotion.  */
1016       if (same_type_p (to, type_promotes_to (from))
1017           && conv->u.next->rank <= cr_promotion)
1018         conv->rank = cr_promotion;
1019     }
1020   else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
1021            && vector_types_convertible_p (from, to, false))
1022     return build_conv (ck_std, to, conv);
1023   else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
1024            && is_properly_derived_from (from, to))
1025     {
1026       if (conv->kind == ck_rvalue)
1027         conv = conv->u.next;
1028       conv = build_conv (ck_base, to, conv);
1029       /* The derived-to-base conversion indicates the initialization
1030          of a parameter with base type from an object of a derived
1031          type.  A temporary object is created to hold the result of
1032          the conversion unless we're binding directly to a reference.  */
1033       conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
1034     }
1035   else
1036     return NULL;
1037
1038   if (flags & LOOKUP_NO_NARROWING)
1039     conv->check_narrowing = true;
1040
1041   return conv;
1042 }
1043
1044 /* Returns nonzero if T1 is reference-related to T2.  */
1045
1046 bool
1047 reference_related_p (tree t1, tree t2)
1048 {
1049   if (t1 == error_mark_node || t2 == error_mark_node)
1050     return false;
1051
1052   t1 = TYPE_MAIN_VARIANT (t1);
1053   t2 = TYPE_MAIN_VARIANT (t2);
1054
1055   /* [dcl.init.ref]
1056
1057      Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
1058      to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
1059      of T2.  */
1060   return (same_type_p (t1, t2)
1061           || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
1062               && DERIVED_FROM_P (t1, t2)));
1063 }
1064
1065 /* Returns nonzero if T1 is reference-compatible with T2.  */
1066
1067 static bool
1068 reference_compatible_p (tree t1, tree t2)
1069 {
1070   /* [dcl.init.ref]
1071
1072      "cv1 T1" is reference compatible with "cv2 T2" if T1 is
1073      reference-related to T2 and cv1 is the same cv-qualification as,
1074      or greater cv-qualification than, cv2.  */
1075   return (reference_related_p (t1, t2)
1076           && at_least_as_qualified_p (t1, t2));
1077 }
1078
1079 /* Determine whether or not the EXPR (of class type S) can be
1080    converted to T as in [over.match.ref].  */
1081
1082 static conversion *
1083 convert_class_to_reference (tree reference_type, tree s, tree expr, int flags)
1084 {
1085   tree conversions;
1086   tree first_arg;
1087   conversion *conv;
1088   tree t;
1089   struct z_candidate *candidates;
1090   struct z_candidate *cand;
1091   bool any_viable_p;
1092
1093   if (!expr)
1094     return NULL;
1095
1096   conversions = lookup_conversions (s);
1097   if (!conversions)
1098     return NULL;
1099
1100   /* [over.match.ref]
1101
1102      Assuming that "cv1 T" is the underlying type of the reference
1103      being initialized, and "cv S" is the type of the initializer
1104      expression, with S a class type, the candidate functions are
1105      selected as follows:
1106
1107      --The conversion functions of S and its base classes are
1108        considered.  Those that are not hidden within S and yield type
1109        "reference to cv2 T2", where "cv1 T" is reference-compatible
1110        (_dcl.init.ref_) with "cv2 T2", are candidate functions.
1111
1112      The argument list has one argument, which is the initializer
1113      expression.  */
1114
1115   candidates = 0;
1116
1117   /* Conceptually, we should take the address of EXPR and put it in
1118      the argument list.  Unfortunately, however, that can result in
1119      error messages, which we should not issue now because we are just
1120      trying to find a conversion operator.  Therefore, we use NULL,
1121      cast to the appropriate type.  */
1122   first_arg = build_int_cst (build_pointer_type (s), 0);
1123
1124   t = TREE_TYPE (reference_type);
1125
1126   /* We're performing a user-defined conversion to a desired type, so set
1127      this for the benefit of add_candidates.  */
1128   flags |= LOOKUP_NO_CONVERSION;
1129
1130   for (; conversions; conversions = TREE_CHAIN (conversions))
1131     {
1132       tree fns = TREE_VALUE (conversions);
1133       tree binfo = TREE_PURPOSE (conversions);
1134       struct z_candidate *old_candidates = candidates;;
1135
1136       add_candidates (fns, first_arg, NULL, reference_type,
1137                       NULL_TREE, false,
1138                       binfo, TYPE_BINFO (s),
1139                       flags, &candidates);
1140
1141       for (cand = candidates; cand != old_candidates; cand = cand->next)
1142         {
1143           /* Now, see if the conversion function really returns
1144              an lvalue of the appropriate type.  From the
1145              point of view of unification, simply returning an
1146              rvalue of the right type is good enough.  */
1147           tree f = cand->fn;
1148           tree t2 = TREE_TYPE (TREE_TYPE (f));
1149           if (TREE_CODE (t2) != REFERENCE_TYPE
1150               || !reference_compatible_p (t, TREE_TYPE (t2)))
1151             {
1152               cand->viable = 0;
1153             }
1154           else
1155             {
1156               conversion *identity_conv;
1157               /* Build a standard conversion sequence indicating the
1158                  binding from the reference type returned by the
1159                  function to the desired REFERENCE_TYPE.  */
1160               identity_conv
1161                 = build_identity_conv (TREE_TYPE (TREE_TYPE
1162                                                   (TREE_TYPE (cand->fn))),
1163                                        NULL_TREE);
1164               cand->second_conv
1165                 = (direct_reference_binding
1166                    (reference_type, identity_conv));
1167               cand->second_conv->rvaluedness_matches_p
1168                 = TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn)))
1169                   == TYPE_REF_IS_RVALUE (reference_type);
1170               cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1171
1172               /* Don't allow binding of lvalues to rvalue references.  */
1173               if (TYPE_REF_IS_RVALUE (reference_type)
1174                   && !TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn))))
1175                 cand->second_conv->bad_p = true;
1176             }
1177         }
1178     }
1179
1180   candidates = splice_viable (candidates, pedantic, &any_viable_p);
1181   /* If none of the conversion functions worked out, let our caller
1182      know.  */
1183   if (!any_viable_p)
1184     return NULL;
1185
1186   cand = tourney (candidates);
1187   if (!cand)
1188     return NULL;
1189
1190   /* Now that we know that this is the function we're going to use fix
1191      the dummy first argument.  */
1192   gcc_assert (cand->first_arg == NULL_TREE
1193               || integer_zerop (cand->first_arg));
1194   cand->first_arg = build_this (expr);
1195
1196   /* Build a user-defined conversion sequence representing the
1197      conversion.  */
1198   conv = build_conv (ck_user,
1199                      TREE_TYPE (TREE_TYPE (cand->fn)),
1200                      build_identity_conv (TREE_TYPE (expr), expr));
1201   conv->cand = cand;
1202
1203   if (cand->viable == -1)
1204     conv->bad_p = true;
1205
1206   /* Merge it with the standard conversion sequence from the
1207      conversion function's return type to the desired type.  */
1208   cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1209
1210   return cand->second_conv;
1211 }
1212
1213 /* A reference of the indicated TYPE is being bound directly to the
1214    expression represented by the implicit conversion sequence CONV.
1215    Return a conversion sequence for this binding.  */
1216
1217 static conversion *
1218 direct_reference_binding (tree type, conversion *conv)
1219 {
1220   tree t;
1221
1222   gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1223   gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1224
1225   t = TREE_TYPE (type);
1226
1227   /* [over.ics.rank]
1228
1229      When a parameter of reference type binds directly
1230      (_dcl.init.ref_) to an argument expression, the implicit
1231      conversion sequence is the identity conversion, unless the
1232      argument expression has a type that is a derived class of the
1233      parameter type, in which case the implicit conversion sequence is
1234      a derived-to-base Conversion.
1235
1236      If the parameter binds directly to the result of applying a
1237      conversion function to the argument expression, the implicit
1238      conversion sequence is a user-defined conversion sequence
1239      (_over.ics.user_), with the second standard conversion sequence
1240      either an identity conversion or, if the conversion function
1241      returns an entity of a type that is a derived class of the
1242      parameter type, a derived-to-base conversion.  */
1243   if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1244     {
1245       /* Represent the derived-to-base conversion.  */
1246       conv = build_conv (ck_base, t, conv);
1247       /* We will actually be binding to the base-class subobject in
1248          the derived class, so we mark this conversion appropriately.
1249          That way, convert_like knows not to generate a temporary.  */
1250       conv->need_temporary_p = false;
1251     }
1252   return build_conv (ck_ref_bind, type, conv);
1253 }
1254
1255 /* Returns the conversion path from type FROM to reference type TO for
1256    purposes of reference binding.  For lvalue binding, either pass a
1257    reference type to FROM or an lvalue expression to EXPR.  If the
1258    reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1259    the conversion returned.  If C_CAST_P is true, this
1260    conversion is coming from a C-style cast.  */
1261
1262 static conversion *
1263 reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1264 {
1265   conversion *conv = NULL;
1266   tree to = TREE_TYPE (rto);
1267   tree from = rfrom;
1268   tree tfrom;
1269   bool related_p;
1270   bool compatible_p;
1271   cp_lvalue_kind is_lvalue = clk_none;
1272
1273   if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1274     {
1275       expr = instantiate_type (to, expr, tf_none);
1276       if (expr == error_mark_node)
1277         return NULL;
1278       from = TREE_TYPE (expr);
1279     }
1280
1281   if (TREE_CODE (from) == REFERENCE_TYPE)
1282     {
1283       /* Anything with reference type is an lvalue.  */
1284       is_lvalue = clk_ordinary;
1285       from = TREE_TYPE (from);
1286     }
1287
1288   if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1289     {
1290       maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
1291       conv = implicit_conversion (to, from, expr, c_cast_p,
1292                                   flags);
1293       if (!CLASS_TYPE_P (to)
1294           && CONSTRUCTOR_NELTS (expr) == 1)
1295         {
1296           expr = CONSTRUCTOR_ELT (expr, 0)->value;
1297           if (error_operand_p (expr))
1298             return NULL;
1299           from = TREE_TYPE (expr);
1300         }
1301     }
1302
1303   if (is_lvalue == clk_none && expr)
1304     is_lvalue = real_lvalue_p (expr);
1305
1306   tfrom = from;
1307   if ((is_lvalue & clk_bitfield) != 0)
1308     tfrom = unlowered_expr_type (expr);
1309
1310   /* Figure out whether or not the types are reference-related and
1311      reference compatible.  We have do do this after stripping
1312      references from FROM.  */
1313   related_p = reference_related_p (to, tfrom);
1314   /* If this is a C cast, first convert to an appropriately qualified
1315      type, so that we can later do a const_cast to the desired type.  */
1316   if (related_p && c_cast_p
1317       && !at_least_as_qualified_p (to, tfrom))
1318     to = cp_build_qualified_type (to, cp_type_quals (tfrom));
1319   compatible_p = reference_compatible_p (to, tfrom);
1320
1321   /* Directly bind reference when target expression's type is compatible with
1322      the reference and expression is an lvalue. In DR391, the wording in
1323      [8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
1324      const and rvalue references to rvalues of compatible class type.
1325      We should also do direct bindings for non-class "rvalues" derived from
1326      rvalue references.  */
1327   if (compatible_p
1328       && (is_lvalue
1329           || (((CP_TYPE_CONST_NON_VOLATILE_P (to)
1330                 && !(flags & LOOKUP_NO_TEMP_BIND))
1331                || TYPE_REF_IS_RVALUE (rto))
1332               && (CLASS_TYPE_P (from) || (expr && lvalue_p (expr))))))
1333     {
1334       /* [dcl.init.ref]
1335
1336          If the initializer expression
1337
1338          -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1339             is reference-compatible with "cv2 T2,"
1340
1341          the reference is bound directly to the initializer expression
1342          lvalue.
1343
1344          [...]
1345          If the initializer expression is an rvalue, with T2 a class type,
1346          and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1347          is bound to the object represented by the rvalue or to a sub-object
1348          within that object.  */
1349
1350       conv = build_identity_conv (tfrom, expr);
1351       conv = direct_reference_binding (rto, conv);
1352
1353       if (flags & LOOKUP_PREFER_RVALUE)
1354         /* The top-level caller requested that we pretend that the lvalue
1355            be treated as an rvalue.  */
1356         conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1357       else
1358         conv->rvaluedness_matches_p
1359           = (TYPE_REF_IS_RVALUE (rto) == !is_lvalue);
1360
1361       if ((is_lvalue & clk_bitfield) != 0
1362           || ((is_lvalue & clk_packed) != 0 && !TYPE_PACKED (to)))
1363         /* For the purposes of overload resolution, we ignore the fact
1364            this expression is a bitfield or packed field. (In particular,
1365            [over.ics.ref] says specifically that a function with a
1366            non-const reference parameter is viable even if the
1367            argument is a bitfield.)
1368
1369            However, when we actually call the function we must create
1370            a temporary to which to bind the reference.  If the
1371            reference is volatile, or isn't const, then we cannot make
1372            a temporary, so we just issue an error when the conversion
1373            actually occurs.  */
1374         conv->need_temporary_p = true;
1375
1376       /* Don't allow binding of lvalues to rvalue references.  */
1377       if (is_lvalue && TYPE_REF_IS_RVALUE (rto)
1378           && !(flags & LOOKUP_PREFER_RVALUE))
1379         conv->bad_p = true;
1380
1381       return conv;
1382     }
1383   /* [class.conv.fct] A conversion function is never used to convert a
1384      (possibly cv-qualified) object to the (possibly cv-qualified) same
1385      object type (or a reference to it), to a (possibly cv-qualified) base
1386      class of that type (or a reference to it).... */
1387   else if (CLASS_TYPE_P (from) && !related_p
1388            && !(flags & LOOKUP_NO_CONVERSION))
1389     {
1390       /* [dcl.init.ref]
1391
1392          If the initializer expression
1393
1394          -- has a class type (i.e., T2 is a class type) can be
1395             implicitly converted to an lvalue of type "cv3 T3," where
1396             "cv1 T1" is reference-compatible with "cv3 T3".  (this
1397             conversion is selected by enumerating the applicable
1398             conversion functions (_over.match.ref_) and choosing the
1399             best one through overload resolution.  (_over.match_).
1400
1401         the reference is bound to the lvalue result of the conversion
1402         in the second case.  */
1403       conv = convert_class_to_reference (rto, from, expr, flags);
1404       if (conv)
1405         return conv;
1406     }
1407
1408   /* From this point on, we conceptually need temporaries, even if we
1409      elide them.  Only the cases above are "direct bindings".  */
1410   if (flags & LOOKUP_NO_TEMP_BIND)
1411     return NULL;
1412
1413   /* [over.ics.rank]
1414
1415      When a parameter of reference type is not bound directly to an
1416      argument expression, the conversion sequence is the one required
1417      to convert the argument expression to the underlying type of the
1418      reference according to _over.best.ics_.  Conceptually, this
1419      conversion sequence corresponds to copy-initializing a temporary
1420      of the underlying type with the argument expression.  Any
1421      difference in top-level cv-qualification is subsumed by the
1422      initialization itself and does not constitute a conversion.  */
1423
1424   /* [dcl.init.ref]
1425
1426      Otherwise, the reference shall be to a non-volatile const type.
1427
1428      Under C++0x, [8.5.3/5 dcl.init.ref] it may also be an rvalue reference */
1429   if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
1430     return NULL;
1431
1432   /* [dcl.init.ref]
1433
1434      Otherwise, a temporary of type "cv1 T1" is created and
1435      initialized from the initializer expression using the rules for a
1436      non-reference copy initialization.  If T1 is reference-related to
1437      T2, cv1 must be the same cv-qualification as, or greater
1438      cv-qualification than, cv2; otherwise, the program is ill-formed.  */
1439   if (related_p && !at_least_as_qualified_p (to, from))
1440     return NULL;
1441
1442   /* We're generating a temporary now, but don't bind any more in the
1443      conversion (specifically, don't slice the temporary returned by a
1444      conversion operator).  */
1445   flags |= LOOKUP_NO_TEMP_BIND;
1446
1447   /* Core issue 899: When [copy-]initializing a temporary to be bound
1448      to the first parameter of a copy constructor (12.8) called with
1449      a single argument in the context of direct-initialization,
1450      explicit conversion functions are also considered.
1451
1452      So don't set LOOKUP_ONLYCONVERTING in that case.  */
1453   if (!(flags & LOOKUP_COPY_PARM))
1454     flags |= LOOKUP_ONLYCONVERTING;
1455
1456   if (!conv)
1457     conv = implicit_conversion (to, from, expr, c_cast_p,
1458                                 flags);
1459   if (!conv)
1460     return NULL;
1461
1462   conv = build_conv (ck_ref_bind, rto, conv);
1463   /* This reference binding, unlike those above, requires the
1464      creation of a temporary.  */
1465   conv->need_temporary_p = true;
1466   conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
1467
1468   return conv;
1469 }
1470
1471 /* Returns the implicit conversion sequence (see [over.ics]) from type
1472    FROM to type TO.  The optional expression EXPR may affect the
1473    conversion.  FLAGS are the usual overloading flags.  If C_CAST_P is
1474    true, this conversion is coming from a C-style cast.  */
1475
1476 static conversion *
1477 implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1478                      int flags)
1479 {
1480   conversion *conv;
1481
1482   if (from == error_mark_node || to == error_mark_node
1483       || expr == error_mark_node)
1484     return NULL;
1485
1486   if (c_dialect_objc ())
1487     from = objc_non_volatilized_type (from);
1488
1489   if (TREE_CODE (to) == REFERENCE_TYPE)
1490     conv = reference_binding (to, from, expr, c_cast_p, flags);
1491   else
1492     conv = standard_conversion (to, from, expr, c_cast_p, flags);
1493
1494   if (conv)
1495     return conv;
1496
1497   if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
1498     {
1499       if (is_std_init_list (to))
1500         return build_list_conv (to, expr, flags);
1501
1502       /* Allow conversion from an initializer-list with one element to a
1503          scalar type.  */
1504       if (SCALAR_TYPE_P (to))
1505         {
1506           int nelts = CONSTRUCTOR_NELTS (expr);
1507           tree elt;
1508
1509           if (nelts == 0)
1510             elt = build_value_init (to, tf_none);
1511           else if (nelts == 1)
1512             elt = CONSTRUCTOR_ELT (expr, 0)->value;
1513           else
1514             elt = error_mark_node;
1515
1516           conv = implicit_conversion (to, TREE_TYPE (elt), elt,
1517                                       c_cast_p, flags);
1518           if (conv)
1519             {
1520               conv->check_narrowing = true;
1521               if (BRACE_ENCLOSED_INITIALIZER_P (elt))
1522                 /* Too many levels of braces, i.e. '{{1}}'.  */
1523                 conv->bad_p = true;
1524               return conv;
1525             }
1526         }
1527     }
1528
1529   if (expr != NULL_TREE
1530       && (MAYBE_CLASS_TYPE_P (from)
1531           || MAYBE_CLASS_TYPE_P (to))
1532       && (flags & LOOKUP_NO_CONVERSION) == 0)
1533     {
1534       struct z_candidate *cand;
1535       int convflags = (flags & (LOOKUP_NO_TEMP_BIND|LOOKUP_ONLYCONVERTING
1536                                 |LOOKUP_NO_NARROWING));
1537
1538       if (CLASS_TYPE_P (to)
1539           && !CLASSTYPE_NON_AGGREGATE (complete_type (to))
1540           && BRACE_ENCLOSED_INITIALIZER_P (expr))
1541         return build_aggr_conv (to, expr, flags);
1542
1543       cand = build_user_type_conversion_1 (to, expr, convflags);
1544       if (cand)
1545         conv = cand->second_conv;
1546
1547       /* We used to try to bind a reference to a temporary here, but that
1548          is now handled after the recursive call to this function at the end
1549          of reference_binding.  */
1550       return conv;
1551     }
1552
1553   return NULL;
1554 }
1555
1556 /* Add a new entry to the list of candidates.  Used by the add_*_candidate
1557    functions.  ARGS will not be changed until a single candidate is
1558    selected.  */
1559
1560 static struct z_candidate *
1561 add_candidate (struct z_candidate **candidates,
1562                tree fn, tree first_arg, const VEC(tree,gc) *args,
1563                size_t num_convs, conversion **convs,
1564                tree access_path, tree conversion_path,
1565                int viable)
1566 {
1567   struct z_candidate *cand = (struct z_candidate *)
1568     conversion_obstack_alloc (sizeof (struct z_candidate));
1569
1570   cand->fn = fn;
1571   cand->first_arg = first_arg;
1572   cand->args = args;
1573   cand->convs = convs;
1574   cand->num_convs = num_convs;
1575   cand->access_path = access_path;
1576   cand->conversion_path = conversion_path;
1577   cand->viable = viable;
1578   cand->next = *candidates;
1579   *candidates = cand;
1580
1581   return cand;
1582 }
1583
1584 /* Create an overload candidate for the function or method FN called
1585    with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
1586    FLAGS is passed on to implicit_conversion.
1587
1588    This does not change ARGS.
1589
1590    CTYPE, if non-NULL, is the type we want to pretend this function
1591    comes from for purposes of overload resolution.  */
1592
1593 static struct z_candidate *
1594 add_function_candidate (struct z_candidate **candidates,
1595                         tree fn, tree ctype, tree first_arg,
1596                         const VEC(tree,gc) *args, tree access_path,
1597                         tree conversion_path, int flags)
1598 {
1599   tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1600   int i, len;
1601   conversion **convs;
1602   tree parmnode;
1603   tree orig_first_arg = first_arg;
1604   int skip;
1605   int viable = 1;
1606
1607   /* At this point we should not see any functions which haven't been
1608      explicitly declared, except for friend functions which will have
1609      been found using argument dependent lookup.  */
1610   gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1611
1612   /* The `this', `in_chrg' and VTT arguments to constructors are not
1613      considered in overload resolution.  */
1614   if (DECL_CONSTRUCTOR_P (fn))
1615     {
1616       parmlist = skip_artificial_parms_for (fn, parmlist);
1617       skip = num_artificial_parms_for (fn);
1618       if (skip > 0 && first_arg != NULL_TREE)
1619         {
1620           --skip;
1621           first_arg = NULL_TREE;
1622         }
1623     }
1624   else
1625     skip = 0;
1626
1627   len = VEC_length (tree, args) - skip + (first_arg != NULL_TREE ? 1 : 0);
1628   convs = alloc_conversions (len);
1629
1630   /* 13.3.2 - Viable functions [over.match.viable]
1631      First, to be a viable function, a candidate function shall have enough
1632      parameters to agree in number with the arguments in the list.
1633
1634      We need to check this first; otherwise, checking the ICSes might cause
1635      us to produce an ill-formed template instantiation.  */
1636
1637   parmnode = parmlist;
1638   for (i = 0; i < len; ++i)
1639     {
1640       if (parmnode == NULL_TREE || parmnode == void_list_node)
1641         break;
1642       parmnode = TREE_CHAIN (parmnode);
1643     }
1644
1645   if (i < len && parmnode)
1646     viable = 0;
1647
1648   /* Make sure there are default args for the rest of the parms.  */
1649   else if (!sufficient_parms_p (parmnode))
1650     viable = 0;
1651
1652   /* Kludge: When looking for a function from a subobject while generating
1653      an implicit copy/move constructor/operator=, don't consider anything
1654      that takes (a reference to) an unrelated type.  See c++/44909.  */
1655   else if (parmlist
1656            && ((flags & LOOKUP_SPECULATIVE)
1657                || (current_function_decl
1658                    && DECL_DEFAULTED_FN (current_function_decl))))
1659     {
1660       if (DECL_CONSTRUCTOR_P (fn))
1661         i = 1;
1662       else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
1663                && DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR)
1664         i = 2;
1665       else
1666         i = 0;
1667       if (i && len == i)
1668         {
1669           parmnode = chain_index (i-1, parmlist);
1670           if (!reference_related_p (non_reference (TREE_VALUE (parmnode)),
1671                                     ctype))
1672             viable = 0;
1673         }
1674     }
1675
1676   if (! viable)
1677     goto out;
1678
1679   /* Second, for F to be a viable function, there shall exist for each
1680      argument an implicit conversion sequence that converts that argument
1681      to the corresponding parameter of F.  */
1682
1683   parmnode = parmlist;
1684
1685   for (i = 0; i < len; ++i)
1686     {
1687       tree arg, argtype;
1688       conversion *t;
1689       int is_this;
1690
1691       if (parmnode == void_list_node)
1692         break;
1693
1694       if (i == 0 && first_arg != NULL_TREE)
1695         arg = first_arg;
1696       else
1697         arg = VEC_index (tree, args,
1698                          i + skip - (first_arg != NULL_TREE ? 1 : 0));
1699       argtype = lvalue_type (arg);
1700
1701       is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1702                  && ! DECL_CONSTRUCTOR_P (fn));
1703
1704       if (parmnode)
1705         {
1706           tree parmtype = TREE_VALUE (parmnode);
1707           int lflags = flags;
1708
1709           parmnode = TREE_CHAIN (parmnode);
1710
1711           /* The type of the implicit object parameter ('this') for
1712              overload resolution is not always the same as for the
1713              function itself; conversion functions are considered to
1714              be members of the class being converted, and functions
1715              introduced by a using-declaration are considered to be
1716              members of the class that uses them.
1717
1718              Since build_over_call ignores the ICS for the `this'
1719              parameter, we can just change the parm type.  */
1720           if (ctype && is_this)
1721             {
1722               parmtype = cp_build_qualified_type
1723                 (ctype, cp_type_quals (TREE_TYPE (parmtype)));
1724               parmtype = build_pointer_type (parmtype);
1725             }
1726
1727           /* Core issue 899: When [copy-]initializing a temporary to be bound
1728              to the first parameter of a copy constructor (12.8) called with
1729              a single argument in the context of direct-initialization,
1730              explicit conversion functions are also considered.
1731
1732              So set LOOKUP_COPY_PARM to let reference_binding know that
1733              it's being called in that context.  We generalize the above
1734              to handle move constructors and template constructors as well;
1735              the standardese should soon be updated similarly.  */
1736           if (ctype && i == 0 && (len-skip == 1)
1737               && !(flags & LOOKUP_ONLYCONVERTING)
1738               && DECL_CONSTRUCTOR_P (fn)
1739               && parmtype != error_mark_node
1740               && (same_type_ignoring_top_level_qualifiers_p
1741                   (non_reference (parmtype), ctype)))
1742             {
1743               lflags |= LOOKUP_COPY_PARM;
1744               /* We allow user-defined conversions within init-lists, but
1745                  not for the copy constructor.  */
1746               if (flags & LOOKUP_NO_COPY_CTOR_CONVERSION)
1747                 lflags |= LOOKUP_NO_CONVERSION;
1748             }
1749           else
1750             lflags |= LOOKUP_ONLYCONVERTING;
1751
1752           t = implicit_conversion (parmtype, argtype, arg,
1753                                    /*c_cast_p=*/false, lflags);
1754         }
1755       else
1756         {
1757           t = build_identity_conv (argtype, arg);
1758           t->ellipsis_p = true;
1759         }
1760
1761       if (t && is_this)
1762         t->this_p = true;
1763
1764       convs[i] = t;
1765       if (! t)
1766         {
1767           viable = 0;
1768           break;
1769         }
1770
1771       if (t->bad_p)
1772         viable = -1;
1773     }
1774
1775  out:
1776   return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
1777                         access_path, conversion_path, viable);
1778 }
1779
1780 /* Create an overload candidate for the conversion function FN which will
1781    be invoked for expression OBJ, producing a pointer-to-function which
1782    will in turn be called with the argument list FIRST_ARG/ARGLIST,
1783    and add it to CANDIDATES.  This does not change ARGLIST.  FLAGS is
1784    passed on to implicit_conversion.
1785
1786    Actually, we don't really care about FN; we care about the type it
1787    converts to.  There may be multiple conversion functions that will
1788    convert to that type, and we rely on build_user_type_conversion_1 to
1789    choose the best one; so when we create our candidate, we record the type
1790    instead of the function.  */
1791
1792 static struct z_candidate *
1793 add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1794                     tree first_arg, const VEC(tree,gc) *arglist,
1795                     tree access_path, tree conversion_path)
1796 {
1797   tree totype = TREE_TYPE (TREE_TYPE (fn));
1798   int i, len, viable, flags;
1799   tree parmlist, parmnode;
1800   conversion **convs;
1801
1802   for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1803     parmlist = TREE_TYPE (parmlist);
1804   parmlist = TYPE_ARG_TYPES (parmlist);
1805
1806   len = VEC_length (tree, arglist) + (first_arg != NULL_TREE ? 1 : 0) + 1;
1807   convs = alloc_conversions (len);
1808   parmnode = parmlist;
1809   viable = 1;
1810   flags = LOOKUP_IMPLICIT;
1811
1812   /* Don't bother looking up the same type twice.  */
1813   if (*candidates && (*candidates)->fn == totype)
1814     return NULL;
1815
1816   for (i = 0; i < len; ++i)
1817     {
1818       tree arg, argtype;
1819       conversion *t;
1820
1821       if (i == 0)
1822         arg = obj;
1823       else if (i == 1 && first_arg != NULL_TREE)
1824         arg = first_arg;
1825       else
1826         arg = VEC_index (tree, arglist,
1827                          i - (first_arg != NULL_TREE ? 1 : 0) - 1);
1828       argtype = lvalue_type (arg);
1829
1830       if (i == 0)
1831         t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1832                                  flags);
1833       else if (parmnode == void_list_node)
1834         break;
1835       else if (parmnode)
1836         t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1837                                  /*c_cast_p=*/false, flags);
1838       else
1839         {
1840           t = build_identity_conv (argtype, arg);
1841           t->ellipsis_p = true;
1842         }
1843
1844       convs[i] = t;
1845       if (! t)
1846         break;
1847
1848       if (t->bad_p)
1849         viable = -1;
1850
1851       if (i == 0)
1852         continue;
1853
1854       if (parmnode)
1855         parmnode = TREE_CHAIN (parmnode);
1856     }
1857
1858   if (i < len)
1859     viable = 0;
1860
1861   if (!sufficient_parms_p (parmnode))
1862     viable = 0;
1863
1864   return add_candidate (candidates, totype, first_arg, arglist, len, convs,
1865                         access_path, conversion_path, viable);
1866 }
1867
1868 static void
1869 build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1870                          tree type1, tree type2, tree *args, tree *argtypes,
1871                          int flags)
1872 {
1873   conversion *t;
1874   conversion **convs;
1875   size_t num_convs;
1876   int viable = 1, i;
1877   tree types[2];
1878
1879   types[0] = type1;
1880   types[1] = type2;
1881
1882   num_convs =  args[2] ? 3 : (args[1] ? 2 : 1);
1883   convs = alloc_conversions (num_convs);
1884
1885   /* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
1886      conversion ops are allowed.  We handle that here by just checking for
1887      boolean_type_node because other operators don't ask for it.  COND_EXPR
1888      also does contextual conversion to bool for the first operand, but we
1889      handle that in build_conditional_expr, and type1 here is operand 2.  */
1890   if (type1 != boolean_type_node)
1891     flags |= LOOKUP_ONLYCONVERTING;
1892
1893   for (i = 0; i < 2; ++i)
1894     {
1895       if (! args[i])
1896         break;
1897
1898       t = implicit_conversion (types[i], argtypes[i], args[i],
1899                                /*c_cast_p=*/false, flags);
1900       if (! t)
1901         {
1902           viable = 0;
1903           /* We need something for printing the candidate.  */
1904           t = build_identity_conv (types[i], NULL_TREE);
1905         }
1906       else if (t->bad_p)
1907         viable = 0;
1908       convs[i] = t;
1909     }
1910
1911   /* For COND_EXPR we rearranged the arguments; undo that now.  */
1912   if (args[2])
1913     {
1914       convs[2] = convs[1];
1915       convs[1] = convs[0];
1916       t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1917                                /*c_cast_p=*/false, flags);
1918       if (t)
1919         convs[0] = t;
1920       else
1921         viable = 0;
1922     }
1923
1924   add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
1925                  num_convs, convs,
1926                  /*access_path=*/NULL_TREE,
1927                  /*conversion_path=*/NULL_TREE,
1928                  viable);
1929 }
1930
1931 static bool
1932 is_complete (tree t)
1933 {
1934   return COMPLETE_TYPE_P (complete_type (t));
1935 }
1936
1937 /* Returns nonzero if TYPE is a promoted arithmetic type.  */
1938
1939 static bool
1940 promoted_arithmetic_type_p (tree type)
1941 {
1942   /* [over.built]
1943
1944      In this section, the term promoted integral type is used to refer
1945      to those integral types which are preserved by integral promotion
1946      (including e.g.  int and long but excluding e.g.  char).
1947      Similarly, the term promoted arithmetic type refers to promoted
1948      integral types plus floating types.  */
1949   return ((CP_INTEGRAL_TYPE_P (type)
1950            && same_type_p (type_promotes_to (type), type))
1951           || TREE_CODE (type) == REAL_TYPE);
1952 }
1953
1954 /* Create any builtin operator overload candidates for the operator in
1955    question given the converted operand types TYPE1 and TYPE2.  The other
1956    args are passed through from add_builtin_candidates to
1957    build_builtin_candidate.
1958
1959    TYPE1 and TYPE2 may not be permissible, and we must filter them.
1960    If CODE is requires candidates operands of the same type of the kind
1961    of which TYPE1 and TYPE2 are, we add both candidates
1962    CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2).  */
1963
1964 static void
1965 add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1966                        enum tree_code code2, tree fnname, tree type1,
1967                        tree type2, tree *args, tree *argtypes, int flags)
1968 {
1969   switch (code)
1970     {
1971     case POSTINCREMENT_EXPR:
1972     case POSTDECREMENT_EXPR:
1973       args[1] = integer_zero_node;
1974       type2 = integer_type_node;
1975       break;
1976     default:
1977       break;
1978     }
1979
1980   switch (code)
1981     {
1982
1983 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
1984      and  VQ  is  either  volatile or empty, there exist candidate operator
1985      functions of the form
1986              VQ T&   operator++(VQ T&);
1987              T       operator++(VQ T&, int);
1988    5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1989      type  other than bool, and VQ is either volatile or empty, there exist
1990      candidate operator functions of the form
1991              VQ T&   operator--(VQ T&);
1992              T       operator--(VQ T&, int);
1993    6 For every pair T, VQ), where T is  a  cv-qualified  or  cv-unqualified
1994      complete  object type, and VQ is either volatile or empty, there exist
1995      candidate operator functions of the form
1996              T*VQ&   operator++(T*VQ&);
1997              T*VQ&   operator--(T*VQ&);
1998              T*      operator++(T*VQ&, int);
1999              T*      operator--(T*VQ&, int);  */
2000
2001     case POSTDECREMENT_EXPR:
2002     case PREDECREMENT_EXPR:
2003       if (TREE_CODE (type1) == BOOLEAN_TYPE)
2004         return;
2005     case POSTINCREMENT_EXPR:
2006     case PREINCREMENT_EXPR:
2007       if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
2008         {
2009           type1 = build_reference_type (type1);
2010           break;
2011         }
2012       return;
2013
2014 /* 7 For every cv-qualified or cv-unqualified complete object type T, there
2015      exist candidate operator functions of the form
2016
2017              T&      operator*(T*);
2018
2019    8 For every function type T, there exist candidate operator functions of
2020      the form
2021              T&      operator*(T*);  */
2022
2023     case INDIRECT_REF:
2024       if (TREE_CODE (type1) == POINTER_TYPE
2025           && is_complete (TREE_TYPE (type1))
2026           && (TYPE_PTROB_P (type1)
2027               || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
2028         break;
2029       return;
2030
2031 /* 9 For every type T, there exist candidate operator functions of the form
2032              T*      operator+(T*);
2033
2034    10For  every  promoted arithmetic type T, there exist candidate operator
2035      functions of the form
2036              T       operator+(T);
2037              T       operator-(T);  */
2038
2039     case UNARY_PLUS_EXPR: /* unary + */
2040       if (TREE_CODE (type1) == POINTER_TYPE)
2041         break;
2042     case NEGATE_EXPR:
2043       if (ARITHMETIC_TYPE_P (type1))
2044         break;
2045       return;
2046
2047 /* 11For every promoted integral type T,  there  exist  candidate  operator
2048      functions of the form
2049              T       operator~(T);  */
2050
2051     case BIT_NOT_EXPR:
2052       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
2053         break;
2054       return;
2055
2056 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2057      is the same type as C2 or is a derived class of C2, T  is  a  complete
2058      object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2059      there exist candidate operator functions of the form
2060              CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2061      where CV12 is the union of CV1 and CV2.  */
2062
2063     case MEMBER_REF:
2064       if (TREE_CODE (type1) == POINTER_TYPE
2065           && TYPE_PTR_TO_MEMBER_P (type2))
2066         {
2067           tree c1 = TREE_TYPE (type1);
2068           tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
2069
2070           if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
2071               && (TYPE_PTRMEMFUNC_P (type2)
2072                   || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
2073             break;
2074         }
2075       return;
2076
2077 /* 13For every pair of promoted arithmetic types L and R, there exist  can-
2078      didate operator functions of the form
2079              LR      operator*(L, R);
2080              LR      operator/(L, R);
2081              LR      operator+(L, R);
2082              LR      operator-(L, R);
2083              bool    operator<(L, R);
2084              bool    operator>(L, R);
2085              bool    operator<=(L, R);
2086              bool    operator>=(L, R);
2087              bool    operator==(L, R);
2088              bool    operator!=(L, R);
2089      where  LR  is  the  result of the usual arithmetic conversions between
2090      types L and R.
2091
2092    14For every pair of types T and I, where T  is  a  cv-qualified  or  cv-
2093      unqualified  complete  object  type and I is a promoted integral type,
2094      there exist candidate operator functions of the form
2095              T*      operator+(T*, I);
2096              T&      operator[](T*, I);
2097              T*      operator-(T*, I);
2098              T*      operator+(I, T*);
2099              T&      operator[](I, T*);
2100
2101    15For every T, where T is a pointer to complete object type, there exist
2102      candidate operator functions of the form112)
2103              ptrdiff_t operator-(T, T);
2104
2105    16For every pointer or enumeration type T, there exist candidate operator
2106      functions of the form
2107              bool    operator<(T, T);
2108              bool    operator>(T, T);
2109              bool    operator<=(T, T);
2110              bool    operator>=(T, T);
2111              bool    operator==(T, T);
2112              bool    operator!=(T, T);
2113
2114    17For every pointer to member type T,  there  exist  candidate  operator
2115      functions of the form
2116              bool    operator==(T, T);
2117              bool    operator!=(T, T);  */
2118
2119     case MINUS_EXPR:
2120       if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
2121         break;
2122       if (TYPE_PTROB_P (type1)
2123           && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2124         {
2125           type2 = ptrdiff_type_node;
2126           break;
2127         }
2128     case MULT_EXPR:
2129     case TRUNC_DIV_EXPR:
2130       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2131         break;
2132       return;
2133
2134     case EQ_EXPR:
2135     case NE_EXPR:
2136       if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2137           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
2138         break;
2139       if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
2140         {
2141           type2 = type1;
2142           break;
2143         }
2144       if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
2145         {
2146           type1 = type2;
2147           break;
2148         }
2149       /* Fall through.  */
2150     case LT_EXPR:
2151     case GT_EXPR:
2152     case LE_EXPR:
2153     case GE_EXPR:
2154     case MAX_EXPR:
2155     case MIN_EXPR:
2156       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2157         break;
2158       if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2159         break;
2160       if (TREE_CODE (type1) == ENUMERAL_TYPE
2161           && TREE_CODE (type2) == ENUMERAL_TYPE)
2162         break;
2163       if (TYPE_PTR_P (type1)
2164           && null_ptr_cst_p (args[1])
2165           && !uses_template_parms (type1))
2166         {
2167           type2 = type1;
2168           break;
2169         }
2170       if (null_ptr_cst_p (args[0])
2171           && TYPE_PTR_P (type2)
2172           && !uses_template_parms (type2))
2173         {
2174           type1 = type2;
2175           break;
2176         }
2177       return;
2178
2179     case PLUS_EXPR:
2180       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2181         break;
2182     case ARRAY_REF:
2183       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2184         {
2185           type1 = ptrdiff_type_node;
2186           break;
2187         }
2188       if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2189         {
2190           type2 = ptrdiff_type_node;
2191           break;
2192         }
2193       return;
2194
2195 /* 18For  every pair of promoted integral types L and R, there exist candi-
2196      date operator functions of the form
2197              LR      operator%(L, R);
2198              LR      operator&(L, R);
2199              LR      operator^(L, R);
2200              LR      operator|(L, R);
2201              L       operator<<(L, R);
2202              L       operator>>(L, R);
2203      where LR is the result of the  usual  arithmetic  conversions  between
2204      types L and R.  */
2205
2206     case TRUNC_MOD_EXPR:
2207     case BIT_AND_EXPR:
2208     case BIT_IOR_EXPR:
2209     case BIT_XOR_EXPR:
2210     case LSHIFT_EXPR:
2211     case RSHIFT_EXPR:
2212       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2213         break;
2214       return;
2215
2216 /* 19For  every  triple  L, VQ, R), where L is an arithmetic or enumeration
2217      type, VQ is either volatile or empty, and R is a  promoted  arithmetic
2218      type, there exist candidate operator functions of the form
2219              VQ L&   operator=(VQ L&, R);
2220              VQ L&   operator*=(VQ L&, R);
2221              VQ L&   operator/=(VQ L&, R);
2222              VQ L&   operator+=(VQ L&, R);
2223              VQ L&   operator-=(VQ L&, R);
2224
2225    20For  every  pair T, VQ), where T is any type and VQ is either volatile
2226      or empty, there exist candidate operator functions of the form
2227              T*VQ&   operator=(T*VQ&, T*);
2228
2229    21For every pair T, VQ), where T is a pointer to member type and  VQ  is
2230      either  volatile or empty, there exist candidate operator functions of
2231      the form
2232              VQ T&   operator=(VQ T&, T);
2233
2234    22For every triple  T,  VQ,  I),  where  T  is  a  cv-qualified  or  cv-
2235      unqualified  complete object type, VQ is either volatile or empty, and
2236      I is a promoted integral type, there exist  candidate  operator  func-
2237      tions of the form
2238              T*VQ&   operator+=(T*VQ&, I);
2239              T*VQ&   operator-=(T*VQ&, I);
2240
2241    23For  every  triple  L,  VQ,  R), where L is an integral or enumeration
2242      type, VQ is either volatile or empty, and R  is  a  promoted  integral
2243      type, there exist candidate operator functions of the form
2244
2245              VQ L&   operator%=(VQ L&, R);
2246              VQ L&   operator<<=(VQ L&, R);
2247              VQ L&   operator>>=(VQ L&, R);
2248              VQ L&   operator&=(VQ L&, R);
2249              VQ L&   operator^=(VQ L&, R);
2250              VQ L&   operator|=(VQ L&, R);  */
2251
2252     case MODIFY_EXPR:
2253       switch (code2)
2254         {
2255         case PLUS_EXPR:
2256         case MINUS_EXPR:
2257           if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2258             {
2259               type2 = ptrdiff_type_node;
2260               break;
2261             }
2262         case MULT_EXPR:
2263         case TRUNC_DIV_EXPR:
2264           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2265             break;
2266           return;
2267
2268         case TRUNC_MOD_EXPR:
2269         case BIT_AND_EXPR:
2270         case BIT_IOR_EXPR:
2271         case BIT_XOR_EXPR:
2272         case LSHIFT_EXPR:
2273         case RSHIFT_EXPR:
2274           if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2275             break;
2276           return;
2277
2278         case NOP_EXPR:
2279           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2280             break;
2281           if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2282               || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2283               || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2284               || ((TYPE_PTRMEMFUNC_P (type1)
2285                    || TREE_CODE (type1) == POINTER_TYPE)
2286                   && null_ptr_cst_p (args[1])))
2287             {
2288               type2 = type1;
2289               break;
2290             }
2291           return;
2292
2293         default:
2294           gcc_unreachable ();
2295         }
2296       type1 = build_reference_type (type1);
2297       break;
2298
2299     case COND_EXPR:
2300       /* [over.built]
2301
2302          For every pair of promoted arithmetic types L and R, there
2303          exist candidate operator functions of the form
2304
2305          LR operator?(bool, L, R);
2306
2307          where LR is the result of the usual arithmetic conversions
2308          between types L and R.
2309
2310          For every type T, where T is a pointer or pointer-to-member
2311          type, there exist candidate operator functions of the form T
2312          operator?(bool, T, T);  */
2313
2314       if (promoted_arithmetic_type_p (type1)
2315           && promoted_arithmetic_type_p (type2))
2316         /* That's OK.  */
2317         break;
2318
2319       /* Otherwise, the types should be pointers.  */
2320       if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2321           || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2322         return;
2323
2324       /* We don't check that the two types are the same; the logic
2325          below will actually create two candidates; one in which both
2326          parameter types are TYPE1, and one in which both parameter
2327          types are TYPE2.  */
2328       break;
2329
2330     default:
2331       gcc_unreachable ();
2332     }
2333
2334   /* If we're dealing with two pointer types or two enumeral types,
2335      we need candidates for both of them.  */
2336   if (type2 && !same_type_p (type1, type2)
2337       && TREE_CODE (type1) == TREE_CODE (type2)
2338       && (TREE_CODE (type1) == REFERENCE_TYPE
2339           || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2340           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2341           || TYPE_PTRMEMFUNC_P (type1)
2342           || MAYBE_CLASS_TYPE_P (type1)
2343           || TREE_CODE (type1) == ENUMERAL_TYPE))
2344     {
2345       build_builtin_candidate
2346         (candidates, fnname, type1, type1, args, argtypes, flags);
2347       build_builtin_candidate
2348         (candidates, fnname, type2, type2, args, argtypes, flags);
2349       return;
2350     }
2351
2352   build_builtin_candidate
2353     (candidates, fnname, type1, type2, args, argtypes, flags);
2354 }
2355
2356 tree
2357 type_decays_to (tree type)
2358 {
2359   if (TREE_CODE (type) == ARRAY_TYPE)
2360     return build_pointer_type (TREE_TYPE (type));
2361   if (TREE_CODE (type) == FUNCTION_TYPE)
2362     return build_pointer_type (type);
2363   if (!MAYBE_CLASS_TYPE_P (type))
2364     type = cv_unqualified (type);
2365   return type;
2366 }
2367
2368 /* There are three conditions of builtin candidates:
2369
2370    1) bool-taking candidates.  These are the same regardless of the input.
2371    2) pointer-pair taking candidates.  These are generated for each type
2372       one of the input types converts to.
2373    3) arithmetic candidates.  According to the standard, we should generate
2374       all of these, but I'm trying not to...
2375
2376    Here we generate a superset of the possible candidates for this particular
2377    case.  That is a subset of the full set the standard defines, plus some
2378    other cases which the standard disallows. add_builtin_candidate will
2379    filter out the invalid set.  */
2380
2381 static void
2382 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2383                         enum tree_code code2, tree fnname, tree *args,
2384                         int flags)
2385 {
2386   int ref1, i;
2387   int enum_p = 0;
2388   tree type, argtypes[3], t;
2389   /* TYPES[i] is the set of possible builtin-operator parameter types
2390      we will consider for the Ith argument.  */
2391   VEC(tree,gc) *types[2];
2392   unsigned ix;
2393
2394   for (i = 0; i < 3; ++i)
2395     {
2396       if (args[i])
2397         argtypes[i] = unlowered_expr_type (args[i]);
2398       else
2399         argtypes[i] = NULL_TREE;
2400     }
2401
2402   switch (code)
2403     {
2404 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
2405      and  VQ  is  either  volatile or empty, there exist candidate operator
2406      functions of the form
2407                  VQ T&   operator++(VQ T&);  */
2408
2409     case POSTINCREMENT_EXPR:
2410     case PREINCREMENT_EXPR:
2411     case POSTDECREMENT_EXPR:
2412     case PREDECREMENT_EXPR:
2413     case MODIFY_EXPR:
2414       ref1 = 1;
2415       break;
2416
2417 /* 24There also exist candidate operator functions of the form
2418              bool    operator!(bool);
2419              bool    operator&&(bool, bool);
2420              bool    operator||(bool, bool);  */
2421
2422     case TRUTH_NOT_EXPR:
2423       build_builtin_candidate
2424         (candidates, fnname, boolean_type_node,
2425          NULL_TREE, args, argtypes, flags);
2426       return;
2427
2428     case TRUTH_ORIF_EXPR:
2429     case TRUTH_ANDIF_EXPR:
2430       build_builtin_candidate
2431         (candidates, fnname, boolean_type_node,
2432          boolean_type_node, args, argtypes, flags);
2433       return;
2434
2435     case ADDR_EXPR:
2436     case COMPOUND_EXPR:
2437     case COMPONENT_REF:
2438       return;
2439
2440     case COND_EXPR:
2441     case EQ_EXPR:
2442     case NE_EXPR:
2443     case LT_EXPR:
2444     case LE_EXPR:
2445     case GT_EXPR:
2446     case GE_EXPR:
2447       enum_p = 1;
2448       /* Fall through.  */
2449
2450     default:
2451       ref1 = 0;
2452     }
2453
2454   types[0] = make_tree_vector ();
2455   types[1] = make_tree_vector ();
2456
2457   for (i = 0; i < 2; ++i)
2458     {
2459       if (! args[i])
2460         ;
2461       else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2462         {
2463           tree convs;
2464
2465           if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2466             return;
2467
2468           convs = lookup_conversions (argtypes[i]);
2469
2470           if (code == COND_EXPR)
2471             {
2472               if (real_lvalue_p (args[i]))
2473                 VEC_safe_push (tree, gc, types[i],
2474                                build_reference_type (argtypes[i]));
2475
2476               VEC_safe_push (tree, gc, types[i],
2477                              TYPE_MAIN_VARIANT (argtypes[i]));
2478             }
2479
2480           else if (! convs)
2481             return;
2482
2483           for (; convs; convs = TREE_CHAIN (convs))
2484             {
2485               type = TREE_TYPE (convs);
2486
2487               if (i == 0 && ref1
2488                   && (TREE_CODE (type) != REFERENCE_TYPE
2489                       || CP_TYPE_CONST_P (TREE_TYPE (type))))
2490                 continue;
2491
2492               if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2493                 VEC_safe_push (tree, gc, types[i], type);
2494
2495               type = non_reference (type);
2496               if (i != 0 || ! ref1)
2497                 {
2498                   type = TYPE_MAIN_VARIANT (type_decays_to (type));
2499                   if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2500                     VEC_safe_push (tree, gc, types[i], type);
2501                   if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2502                     type = type_promotes_to (type);
2503                 }
2504
2505               if (! vec_member (type, types[i]))
2506                 VEC_safe_push (tree, gc, types[i], type);
2507             }
2508         }
2509       else
2510         {
2511           if (code == COND_EXPR && real_lvalue_p (args[i]))
2512             VEC_safe_push (tree, gc, types[i],
2513                            build_reference_type (argtypes[i]));
2514           type = non_reference (argtypes[i]);
2515           if (i != 0 || ! ref1)
2516             {
2517               type = TYPE_MAIN_VARIANT (type_decays_to (type));
2518               if (enum_p && UNSCOPED_ENUM_P (type))
2519                 VEC_safe_push (tree, gc, types[i], type);
2520               if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2521                 type = type_promotes_to (type);
2522             }
2523           VEC_safe_push (tree, gc, types[i], type);
2524         }
2525     }
2526
2527   /* Run through the possible parameter types of both arguments,
2528      creating candidates with those parameter types.  */
2529   FOR_EACH_VEC_ELT_REVERSE (tree, types[0], ix, t)
2530     {
2531       unsigned jx;
2532       tree u;
2533
2534       if (!VEC_empty (tree, types[1]))
2535         FOR_EACH_VEC_ELT_REVERSE (tree, types[1], jx, u)
2536           add_builtin_candidate
2537             (candidates, code, code2, fnname, t,
2538              u, args, argtypes, flags);
2539       else
2540         add_builtin_candidate
2541           (candidates, code, code2, fnname, t,
2542            NULL_TREE, args, argtypes, flags);
2543     }
2544
2545   release_tree_vector (types[0]);
2546   release_tree_vector (types[1]);
2547 }
2548
2549
2550 /* If TMPL can be successfully instantiated as indicated by
2551    EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2552
2553    TMPL is the template.  EXPLICIT_TARGS are any explicit template
2554    arguments.  ARGLIST is the arguments provided at the call-site.
2555    This does not change ARGLIST.  The RETURN_TYPE is the desired type
2556    for conversion operators.  If OBJ is NULL_TREE, FLAGS and CTYPE are
2557    as for add_function_candidate.  If an OBJ is supplied, FLAGS and
2558    CTYPE are ignored, and OBJ is as for add_conv_candidate.  */
2559
2560 static struct z_candidate*
2561 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2562                              tree ctype, tree explicit_targs, tree first_arg,
2563                              const VEC(tree,gc) *arglist, tree return_type,
2564                              tree access_path, tree conversion_path,
2565                              int flags, tree obj, unification_kind_t strict)
2566 {
2567   int ntparms = DECL_NTPARMS (tmpl);
2568   tree targs = make_tree_vec (ntparms);
2569   unsigned int len = VEC_length (tree, arglist);
2570   unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len;
2571   unsigned int skip_without_in_chrg = 0;
2572   tree first_arg_without_in_chrg = first_arg;
2573   tree *args_without_in_chrg;
2574   unsigned int nargs_without_in_chrg;
2575   unsigned int ia, ix;
2576   tree arg;
2577   struct z_candidate *cand;
2578   int i;
2579   tree fn;
2580
2581   /* We don't do deduction on the in-charge parameter, the VTT
2582      parameter or 'this'.  */
2583   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2584     {
2585       if (first_arg_without_in_chrg != NULL_TREE)
2586         first_arg_without_in_chrg = NULL_TREE;
2587       else
2588         ++skip_without_in_chrg;
2589     }
2590
2591   if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2592        || DECL_BASE_CONSTRUCTOR_P (tmpl))
2593       && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2594     {
2595       if (first_arg_without_in_chrg != NULL_TREE)
2596         first_arg_without_in_chrg = NULL_TREE;
2597       else
2598         ++skip_without_in_chrg;
2599     }
2600
2601   if (len < skip_without_in_chrg)
2602     return NULL;
2603
2604   nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2605                            + (len - skip_without_in_chrg));
2606   args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2607   ia = 0;
2608   if (first_arg_without_in_chrg != NULL_TREE)
2609     {
2610       args_without_in_chrg[ia] = first_arg_without_in_chrg;
2611       ++ia;
2612     }
2613   for (ix = skip_without_in_chrg;
2614        VEC_iterate (tree, arglist, ix, arg);
2615        ++ix)
2616     {
2617       args_without_in_chrg[ia] = arg;
2618       ++ia;
2619     }
2620   gcc_assert (ia == nargs_without_in_chrg);
2621
2622   i = fn_type_unification (tmpl, explicit_targs, targs,
2623                            args_without_in_chrg,
2624                            nargs_without_in_chrg,
2625                            return_type, strict, flags);
2626
2627   if (i != 0)
2628     goto fail;
2629
2630   fn = instantiate_template (tmpl, targs, tf_none);
2631   if (fn == error_mark_node)
2632     goto fail;
2633
2634   /* In [class.copy]:
2635
2636        A member function template is never instantiated to perform the
2637        copy of a class object to an object of its class type.
2638
2639      It's a little unclear what this means; the standard explicitly
2640      does allow a template to be used to copy a class.  For example,
2641      in:
2642
2643        struct A {
2644          A(A&);
2645          template <class T> A(const T&);
2646        };
2647        const A f ();
2648        void g () { A a (f ()); }
2649
2650      the member template will be used to make the copy.  The section
2651      quoted above appears in the paragraph that forbids constructors
2652      whose only parameter is (a possibly cv-qualified variant of) the
2653      class type, and a logical interpretation is that the intent was
2654      to forbid the instantiation of member templates which would then
2655      have that form.  */
2656   if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2657     {
2658       tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2659       if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2660                                     ctype))
2661         goto fail;
2662     }
2663
2664   if (obj != NULL_TREE)
2665     /* Aha, this is a conversion function.  */
2666     cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2667                                access_path, conversion_path);
2668   else
2669     cand = add_function_candidate (candidates, fn, ctype,
2670                                    first_arg, arglist, access_path,
2671                                    conversion_path, flags);
2672   if (DECL_TI_TEMPLATE (fn) != tmpl)
2673     /* This situation can occur if a member template of a template
2674        class is specialized.  Then, instantiate_template might return
2675        an instantiation of the specialization, in which case the
2676        DECL_TI_TEMPLATE field will point at the original
2677        specialization.  For example:
2678
2679          template <class T> struct S { template <class U> void f(U);
2680                                        template <> void f(int) {}; };
2681          S<double> sd;
2682          sd.f(3);
2683
2684        Here, TMPL will be template <class U> S<double>::f(U).
2685        And, instantiate template will give us the specialization
2686        template <> S<double>::f(int).  But, the DECL_TI_TEMPLATE field
2687        for this will point at template <class T> template <> S<T>::f(int),
2688        so that we can find the definition.  For the purposes of
2689        overload resolution, however, we want the original TMPL.  */
2690     cand->template_decl = build_template_info (tmpl, targs);
2691   else
2692     cand->template_decl = DECL_TEMPLATE_INFO (fn);
2693   cand->explicit_targs = explicit_targs;
2694
2695   return cand;
2696  fail:
2697   return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
2698                         access_path, conversion_path, 0);
2699 }
2700
2701
2702 static struct z_candidate *
2703 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2704                         tree explicit_targs, tree first_arg,
2705                         const VEC(tree,gc) *arglist, tree return_type,
2706                         tree access_path, tree conversion_path, int flags,
2707                         unification_kind_t strict)
2708 {
2709   return
2710     add_template_candidate_real (candidates, tmpl, ctype,
2711                                  explicit_targs, first_arg, arglist,
2712                                  return_type, access_path, conversion_path,
2713                                  flags, NULL_TREE, strict);
2714 }
2715
2716
2717 static struct z_candidate *
2718 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2719                              tree obj, tree first_arg,
2720                              const VEC(tree,gc) *arglist,
2721                              tree return_type, tree access_path,
2722                              tree conversion_path)
2723 {
2724   return
2725     add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2726                                  first_arg, arglist, return_type, access_path,
2727                                  conversion_path, 0, obj, DEDUCE_CONV);
2728 }
2729
2730 /* The CANDS are the set of candidates that were considered for
2731    overload resolution.  Return the set of viable candidates, or CANDS
2732    if none are viable.  If any of the candidates were viable, set
2733    *ANY_VIABLE_P to true.  STRICT_P is true if a candidate should be
2734    considered viable only if it is strictly viable.  */
2735
2736 static struct z_candidate*
2737 splice_viable (struct z_candidate *cands,
2738                bool strict_p,
2739                bool *any_viable_p)
2740 {
2741   struct z_candidate *viable;
2742   struct z_candidate **last_viable;
2743   struct z_candidate **cand;
2744
2745   viable = NULL;
2746   last_viable = &viable;
2747   *any_viable_p = false;
2748
2749   cand = &cands;
2750   while (*cand)
2751     {
2752       struct z_candidate *c = *cand;
2753       if (strict_p ? c->viable == 1 : c->viable)
2754         {
2755           *last_viable = c;
2756           *cand = c->next;
2757           c->next = NULL;
2758           last_viable = &c->next;
2759           *any_viable_p = true;
2760         }
2761       else
2762         cand = &c->next;
2763     }
2764
2765   return viable ? viable : cands;
2766 }
2767
2768 static bool
2769 any_strictly_viable (struct z_candidate *cands)
2770 {
2771   for (; cands; cands = cands->next)
2772     if (cands->viable == 1)
2773       return true;
2774   return false;
2775 }
2776
2777 /* OBJ is being used in an expression like "OBJ.f (...)".  In other
2778    words, it is about to become the "this" pointer for a member
2779    function call.  Take the address of the object.  */
2780
2781 static tree
2782 build_this (tree obj)
2783 {
2784   /* In a template, we are only concerned about the type of the
2785      expression, so we can take a shortcut.  */
2786   if (processing_template_decl)
2787     return build_address (obj);
2788
2789   return cp_build_addr_expr (obj, tf_warning_or_error);
2790 }
2791
2792 /* Returns true iff functions are equivalent. Equivalent functions are
2793    not '==' only if one is a function-local extern function or if
2794    both are extern "C".  */
2795
2796 static inline int
2797 equal_functions (tree fn1, tree fn2)
2798 {
2799   if (TREE_CODE (fn1) != TREE_CODE (fn2))
2800     return 0;
2801   if (TREE_CODE (fn1) == TEMPLATE_DECL)
2802     return fn1 == fn2;
2803   if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2804       || DECL_EXTERN_C_FUNCTION_P (fn1))
2805     return decls_match (fn1, fn2);
2806   return fn1 == fn2;
2807 }
2808
2809 /* Print information about one overload candidate CANDIDATE.  MSGSTR
2810    is the text to print before the candidate itself.
2811
2812    NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2813    to have been run through gettext by the caller.  This wart makes
2814    life simpler in print_z_candidates and for the translators.  */
2815
2816 static void
2817 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2818 {
2819   if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2820     {
2821       if (candidate->num_convs == 3)
2822         inform (input_location, "%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2823                 candidate->convs[0]->type,
2824                 candidate->convs[1]->type,
2825                 candidate->convs[2]->type);
2826       else if (candidate->num_convs == 2)
2827         inform (input_location, "%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2828                 candidate->convs[0]->type,
2829                 candidate->convs[1]->type);
2830       else
2831         inform (input_location, "%s %D(%T) <built-in>", msgstr, candidate->fn,
2832                 candidate->convs[0]->type);
2833     }
2834   else if (TYPE_P (candidate->fn))
2835     inform (input_location, "%s %T <conversion>", msgstr, candidate->fn);
2836   else if (candidate->viable == -1)
2837     inform (input_location, "%s %+#D <near match>", msgstr, candidate->fn);
2838   else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
2839     inform (input_location, "%s %+#D <deleted>", msgstr, candidate->fn);
2840   else
2841     inform (input_location, "%s %+#D", msgstr, candidate->fn);
2842 }
2843
2844 static void
2845 print_z_candidates (struct z_candidate *candidates)
2846 {
2847   const char *str;
2848   struct z_candidate *cand1;
2849   struct z_candidate **cand2;
2850   char *spaces;
2851
2852   if (!candidates)
2853     return;
2854
2855   /* Remove non-viable deleted candidates.  */
2856   cand1 = candidates;
2857   for (cand2 = &cand1; *cand2; )
2858     {
2859       if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2860           && !(*cand2)->viable
2861           && DECL_DELETED_FN ((*cand2)->fn))
2862         *cand2 = (*cand2)->next;
2863       else
2864         cand2 = &(*cand2)->next;
2865     }
2866   /* ...if there are any non-deleted ones.  */
2867   if (cand1)
2868     candidates = cand1;
2869
2870   /* There may be duplicates in the set of candidates.  We put off
2871      checking this condition as long as possible, since we have no way
2872      to eliminate duplicates from a set of functions in less than n^2
2873      time.  Now we are about to emit an error message, so it is more
2874      permissible to go slowly.  */
2875   for (cand1 = candidates; cand1; cand1 = cand1->next)
2876     {
2877       tree fn = cand1->fn;
2878       /* Skip builtin candidates and conversion functions.  */
2879       if (!DECL_P (fn))
2880         continue;
2881       cand2 = &cand1->next;
2882       while (*cand2)
2883         {
2884           if (DECL_P ((*cand2)->fn)
2885               && equal_functions (fn, (*cand2)->fn))
2886             *cand2 = (*cand2)->next;
2887           else
2888             cand2 = &(*cand2)->next;
2889         }
2890     }
2891
2892   str = candidates->next ? _("candidates are:") :  _("candidate is:");
2893   spaces = NULL;
2894   for (; candidates; candidates = candidates->next)
2895     {
2896       print_z_candidate (spaces ? spaces : str, candidates);
2897       spaces = spaces ? spaces : get_spaces (str);
2898     }
2899   free (spaces);
2900 }
2901
2902 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2903    USER_CONV.  STD_SEQ is the standard conversion sequence applied to
2904    the result of the conversion function to convert it to the final
2905    desired type.  Merge the two sequences into a single sequence,
2906    and return the merged sequence.  */
2907
2908 static conversion *
2909 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2910 {
2911   conversion **t;
2912
2913   gcc_assert (user_seq->kind == ck_user);
2914
2915   /* Find the end of the second conversion sequence.  */
2916   t = &(std_seq);
2917   while ((*t)->kind != ck_identity)
2918     t = &((*t)->u.next);
2919
2920   /* Replace the identity conversion with the user conversion
2921      sequence.  */
2922   *t = user_seq;
2923
2924   /* The entire sequence is a user-conversion sequence.  */
2925   std_seq->user_conv_p = true;
2926
2927   return std_seq;
2928 }
2929
2930 /* Handle overload resolution for initializing an object of class type from
2931    an initializer list.  First we look for a suitable constructor that
2932    takes a std::initializer_list; if we don't find one, we then look for a
2933    non-list constructor.
2934
2935    Parameters are as for add_candidates, except that the arguments are in
2936    the form of a CONSTRUCTOR (the initializer list) rather than a VEC, and
2937    the RETURN_TYPE parameter is replaced by TOTYPE, the desired type.  */
2938
2939 static void
2940 add_list_candidates (tree fns, tree first_arg,
2941                      tree init_list, tree totype,
2942                      tree explicit_targs, bool template_only,
2943                      tree conversion_path, tree access_path,
2944                      int flags,
2945                      struct z_candidate **candidates)
2946 {
2947   VEC(tree,gc) *args;
2948
2949   gcc_assert (*candidates == NULL);
2950
2951   /* For list-initialization we consider explicit constructors, but
2952      give an error if one is selected.  */
2953   flags &= ~LOOKUP_ONLYCONVERTING;
2954   /* And we don't allow narrowing conversions.  We also use this flag to
2955      avoid the copy constructor call for copy-list-initialization.  */
2956   flags |= LOOKUP_NO_NARROWING;
2957
2958   /* Always use the default constructor if the list is empty (DR 990).  */
2959   if (CONSTRUCTOR_NELTS (init_list) == 0
2960       && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype))
2961     ;
2962   /* If the class has a list ctor, try passing the list as a single
2963      argument first, but only consider list ctors.  */
2964   else if (TYPE_HAS_LIST_CTOR (totype))
2965     {
2966       flags |= LOOKUP_LIST_ONLY;
2967       args = make_tree_vector_single (init_list);
2968       add_candidates (fns, first_arg, args, NULL_TREE,
2969                       explicit_targs, template_only, conversion_path,
2970                       access_path, flags, candidates);
2971       if (any_strictly_viable (*candidates))
2972         return;
2973     }
2974
2975   args = ctor_to_vec (init_list);
2976
2977   /* We aren't looking for list-ctors anymore.  */
2978   flags &= ~LOOKUP_LIST_ONLY;
2979   /* We allow more user-defined conversions within an init-list.  */
2980   flags &= ~LOOKUP_NO_CONVERSION;
2981   /* But not for the copy ctor.  */
2982   flags |= LOOKUP_NO_COPY_CTOR_CONVERSION;
2983
2984   add_candidates (fns, first_arg, args, NULL_TREE,
2985                   explicit_targs, template_only, conversion_path,
2986                   access_path, flags, candidates);
2987 }
2988
2989 /* Returns the best overload candidate to perform the requested
2990    conversion.  This function is used for three the overloading situations
2991    described in [over.match.copy], [over.match.conv], and [over.match.ref].
2992    If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2993    per [dcl.init.ref], so we ignore temporary bindings.  */
2994
2995 static struct z_candidate *
2996 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2997 {
2998   struct z_candidate *candidates, *cand;
2999   tree fromtype = TREE_TYPE (expr);
3000   tree ctors = NULL_TREE;
3001   tree conv_fns = NULL_TREE;
3002   conversion *conv = NULL;
3003   tree first_arg = NULL_TREE;
3004   VEC(tree,gc) *args = NULL;
3005   bool any_viable_p;
3006   int convflags;
3007
3008   /* We represent conversion within a hierarchy using RVALUE_CONV and
3009      BASE_CONV, as specified by [over.best.ics]; these become plain
3010      constructor calls, as specified in [dcl.init].  */
3011   gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
3012               || !DERIVED_FROM_P (totype, fromtype));
3013
3014   if (MAYBE_CLASS_TYPE_P (totype))
3015     ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
3016
3017   if (MAYBE_CLASS_TYPE_P (fromtype))
3018     {
3019       tree to_nonref = non_reference (totype);
3020       if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
3021           (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
3022            && DERIVED_FROM_P (to_nonref, fromtype)))
3023         {
3024           /* [class.conv.fct] A conversion function is never used to
3025              convert a (possibly cv-qualified) object to the (possibly
3026              cv-qualified) same object type (or a reference to it), to a
3027              (possibly cv-qualified) base class of that type (or a
3028              reference to it)...  */
3029         }
3030       else
3031         conv_fns = lookup_conversions (fromtype);
3032     }
3033
3034   candidates = 0;
3035   flags |= LOOKUP_NO_CONVERSION;
3036   if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3037     flags |= LOOKUP_NO_NARROWING;
3038
3039   /* It's OK to bind a temporary for converting constructor arguments, but
3040      not in converting the return value of a conversion operator.  */
3041   convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
3042   flags &= ~LOOKUP_NO_TEMP_BIND;
3043
3044   if (ctors)
3045     {
3046       int ctorflags = flags;
3047       ctors = BASELINK_FUNCTIONS (ctors);
3048
3049       first_arg = build_int_cst (build_pointer_type (totype), 0);
3050
3051       /* We should never try to call the abstract or base constructor
3052          from here.  */
3053       gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
3054                   && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
3055
3056       if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3057         {
3058           /* List-initialization.  */
3059           add_list_candidates (ctors, first_arg, expr, totype, NULL_TREE,
3060                                false, TYPE_BINFO (totype), TYPE_BINFO (totype),
3061                                ctorflags, &candidates);
3062         }
3063       else
3064         {
3065           args = make_tree_vector_single (expr);
3066           add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
3067                           TYPE_BINFO (totype), TYPE_BINFO (totype),
3068                           ctorflags, &candidates);
3069         }
3070
3071       for (cand = candidates; cand; cand = cand->next)
3072         {
3073           cand->second_conv = build_identity_conv (totype, NULL_TREE);
3074
3075           /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3076              set, then this is copy-initialization.  In that case, "The
3077              result of the call is then used to direct-initialize the
3078              object that is the destination of the copy-initialization."
3079              [dcl.init]
3080
3081              We represent this in the conversion sequence with an
3082              rvalue conversion, which means a constructor call.  */
3083           if (TREE_CODE (totype) != REFERENCE_TYPE
3084               && !(convflags & LOOKUP_NO_TEMP_BIND))
3085             cand->second_conv
3086               = build_conv (ck_rvalue, totype, cand->second_conv);
3087         }
3088     }
3089
3090   if (conv_fns)
3091     first_arg = build_this (expr);
3092
3093   for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
3094     {
3095       tree conversion_path = TREE_PURPOSE (conv_fns);
3096       struct z_candidate *old_candidates;
3097
3098       /* If we are called to convert to a reference type, we are trying to
3099          find an lvalue binding, so don't even consider temporaries.  If
3100          we don't find an lvalue binding, the caller will try again to
3101          look for a temporary binding.  */
3102       if (TREE_CODE (totype) == REFERENCE_TYPE)
3103         convflags |= LOOKUP_NO_TEMP_BIND;
3104
3105       old_candidates = candidates;
3106       add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
3107                       NULL_TREE, false,
3108                       conversion_path, TYPE_BINFO (fromtype),
3109                       flags, &candidates);
3110
3111       for (cand = candidates; cand != old_candidates; cand = cand->next)
3112         {
3113           conversion *ics
3114             = implicit_conversion (totype,
3115                                    TREE_TYPE (TREE_TYPE (cand->fn)),
3116                                    0,
3117                                    /*c_cast_p=*/false, convflags);
3118
3119           /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3120              copy-initialization.  In that case, "The result of the
3121              call is then used to direct-initialize the object that is
3122              the destination of the copy-initialization."  [dcl.init]
3123
3124              We represent this in the conversion sequence with an
3125              rvalue conversion, which means a constructor call.  But
3126              don't add a second rvalue conversion if there's already
3127              one there.  Which there really shouldn't be, but it's
3128              harmless since we'd add it here anyway. */
3129           if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
3130               && !(convflags & LOOKUP_NO_TEMP_BIND))
3131             ics = build_conv (ck_rvalue, totype, ics);
3132
3133           cand->second_conv = ics;
3134
3135           if (!ics)
3136             cand->viable = 0;
3137           else if (cand->viable == 1 && ics->bad_p)
3138             cand->viable = -1;
3139         }
3140     }
3141
3142   candidates = splice_viable (candidates, pedantic, &any_viable_p);
3143   if (!any_viable_p)
3144     return NULL;
3145
3146   cand = tourney (candidates);
3147   if (cand == 0)
3148     {
3149       if (flags & LOOKUP_COMPLAIN)
3150         {
3151           error ("conversion from %qT to %qT is ambiguous",
3152                     fromtype, totype);
3153           print_z_candidates (candidates);
3154         }
3155
3156       cand = candidates;        /* any one will do */
3157       cand->second_conv = build_ambiguous_conv (totype, expr);
3158       cand->second_conv->user_conv_p = true;
3159       if (!any_strictly_viable (candidates))
3160         cand->second_conv->bad_p = true;
3161       /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3162          ambiguous conversion is no worse than another user-defined
3163          conversion.  */
3164
3165       return cand;
3166     }
3167
3168   /* Build the user conversion sequence.  */
3169   conv = build_conv
3170     (ck_user,
3171      (DECL_CONSTRUCTOR_P (cand->fn)
3172       ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3173      build_identity_conv (TREE_TYPE (expr), expr));
3174   conv->cand = cand;
3175
3176   /* Remember that this was a list-initialization.  */
3177   if (flags & LOOKUP_NO_NARROWING)
3178     conv->check_narrowing = true;
3179
3180   /* Combine it with the second conversion sequence.  */
3181   cand->second_conv = merge_conversion_sequences (conv,
3182                                                   cand->second_conv);
3183
3184   if (cand->viable == -1)
3185     cand->second_conv->bad_p = true;
3186
3187   return cand;
3188 }
3189
3190 tree
3191 build_user_type_conversion (tree totype, tree expr, int flags)
3192 {
3193   struct z_candidate *cand
3194     = build_user_type_conversion_1 (totype, expr, flags);
3195
3196   if (cand)
3197     {
3198       if (cand->second_conv->kind == ck_ambig)
3199         return error_mark_node;
3200       expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
3201       return convert_from_reference (expr);
3202     }
3203   return NULL_TREE;
3204 }
3205
3206 /* Subroutine of convert_nontype_argument.
3207
3208    EXPR is an argument for a template non-type parameter of integral or
3209    enumeration type.  Do any necessary conversions (that are permitted for
3210    non-type arguments) to convert it to the parameter type.
3211
3212    If conversion is successful, returns the converted expression;
3213    otherwise, returns error_mark_node.  */
3214
3215 tree
3216 build_integral_nontype_arg_conv (tree type, tree expr, tsubst_flags_t complain)
3217 {
3218   conversion *conv;
3219   void *p;
3220   tree t;
3221
3222   if (error_operand_p (expr))
3223     return error_mark_node;
3224
3225   gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
3226
3227   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3228   p = conversion_obstack_alloc (0);
3229
3230   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
3231                               /*c_cast_p=*/false,
3232                               LOOKUP_IMPLICIT);
3233
3234   /* for a non-type template-parameter of integral or
3235      enumeration type, integral promotions (4.5) and integral
3236      conversions (4.7) are applied.  */
3237   /* It should be sufficient to check the outermost conversion step, since
3238      there are no qualification conversions to integer type.  */
3239   if (conv)
3240     switch (conv->kind)
3241       {
3242         /* A conversion function is OK.  If it isn't constexpr, we'll
3243            complain later that the argument isn't constant.  */
3244       case ck_user:
3245         /* The lvalue-to-rvalue conversion is OK.  */
3246       case ck_rvalue:
3247       case ck_identity:
3248         break;
3249
3250       case ck_std:
3251         t = conv->u.next->type;
3252         if (INTEGRAL_OR_ENUMERATION_TYPE_P (t))
3253           break;
3254
3255         if (complain & tf_error)
3256           error ("conversion from %qT to %qT not considered for "
3257                  "non-type template argument", t, type);
3258         /* and fall through.  */
3259
3260       default:
3261         conv = NULL;
3262         break;
3263       }
3264
3265   if (conv)
3266     expr = convert_like (conv, expr, complain);
3267   else
3268     expr = error_mark_node;
3269
3270   /* Free all the conversions we allocated.  */
3271   obstack_free (&conversion_obstack, p);
3272
3273   return expr;
3274 }
3275
3276 /* Do any initial processing on the arguments to a function call.  */
3277
3278 static VEC(tree,gc) *
3279 resolve_args (VEC(tree,gc) *args)
3280 {
3281   unsigned int ix;
3282   tree arg;
3283
3284   FOR_EACH_VEC_ELT (tree, args, ix, arg)
3285     {
3286       if (error_operand_p (arg))
3287         return NULL;
3288       else if (VOID_TYPE_P (TREE_TYPE (arg)))
3289         {
3290           error ("invalid use of void expression");
3291           return NULL;
3292         }
3293       else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3294         return NULL;
3295     }
3296   return args;
3297 }
3298
3299 /* Perform overload resolution on FN, which is called with the ARGS.
3300
3301    Return the candidate function selected by overload resolution, or
3302    NULL if the event that overload resolution failed.  In the case
3303    that overload resolution fails, *CANDIDATES will be the set of
3304    candidates considered, and ANY_VIABLE_P will be set to true or
3305    false to indicate whether or not any of the candidates were
3306    viable.
3307
3308    The ARGS should already have gone through RESOLVE_ARGS before this
3309    function is called.  */
3310
3311 static struct z_candidate *
3312 perform_overload_resolution (tree fn,
3313                              const VEC(tree,gc) *args,
3314                              struct z_candidate **candidates,
3315                              bool *any_viable_p)
3316 {
3317   struct z_candidate *cand;
3318   tree explicit_targs = NULL_TREE;
3319   int template_only = 0;
3320
3321   *candidates = NULL;
3322   *any_viable_p = true;
3323
3324   /* Check FN.  */
3325   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3326               || TREE_CODE (fn) == TEMPLATE_DECL
3327               || TREE_CODE (fn) == OVERLOAD
3328               || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3329
3330   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3331     {
3332       explicit_targs = TREE_OPERAND (fn, 1);
3333       fn = TREE_OPERAND (fn, 0);
3334       template_only = 1;
3335     }
3336
3337   /* Add the various candidate functions.  */
3338   add_candidates (fn, NULL_TREE, args, NULL_TREE,
3339                   explicit_targs, template_only,
3340                   /*conversion_path=*/NULL_TREE,
3341                   /*access_path=*/NULL_TREE,
3342                   LOOKUP_NORMAL,
3343                   candidates);
3344
3345   *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3346   if (!*any_viable_p)
3347     return NULL;
3348
3349   cand = tourney (*candidates);
3350   return cand;
3351 }
3352
3353 /* Return an expression for a call to FN (a namespace-scope function,
3354    or a static member function) with the ARGS.  This may change
3355    ARGS.  */
3356
3357 tree
3358 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p,
3359                          tsubst_flags_t complain)
3360 {
3361   struct z_candidate *candidates, *cand;
3362   bool any_viable_p;
3363   void *p;
3364   tree result;
3365
3366   if (args != NULL && *args != NULL)
3367     {
3368       *args = resolve_args (*args);
3369       if (*args == NULL)
3370         return error_mark_node;
3371     }
3372
3373   /* If this function was found without using argument dependent
3374      lookup, then we want to ignore any undeclared friend
3375      functions.  */
3376   if (!koenig_p)
3377     {
3378       tree orig_fn = fn;
3379
3380       fn = remove_hidden_names (fn);
3381       if (!fn)
3382         {
3383           if (complain & tf_error)
3384             error ("no matching function for call to %<%D(%A)%>",
3385                    DECL_NAME (OVL_CURRENT (orig_fn)),
3386                    build_tree_list_vec (*args));
3387           return error_mark_node;
3388         }
3389     }
3390
3391   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3392   p = conversion_obstack_alloc (0);
3393
3394   cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3395
3396   if (!cand)
3397     {
3398       if (complain & tf_error)
3399         {
3400           if (!any_viable_p && candidates && ! candidates->next
3401               && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3402             return cp_build_function_call_vec (candidates->fn, args, complain);
3403           if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3404             fn = TREE_OPERAND (fn, 0);
3405           if (!any_viable_p)
3406             error ("no matching function for call to %<%D(%A)%>",
3407                    DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3408           else
3409             error ("call of overloaded %<%D(%A)%> is ambiguous",
3410                    DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3411           if (candidates)
3412             print_z_candidates (candidates);
3413         }
3414       result = error_mark_node;
3415     }
3416   else
3417     result = build_over_call (cand, LOOKUP_NORMAL, complain);
3418
3419   /* Free all the conversions we allocated.  */
3420   obstack_free (&conversion_obstack, p);
3421
3422   return result;
3423 }
3424
3425 /* Build a call to a global operator new.  FNNAME is the name of the
3426    operator (either "operator new" or "operator new[]") and ARGS are
3427    the arguments provided.  This may change ARGS.  *SIZE points to the
3428    total number of bytes required by the allocation, and is updated if
3429    that is changed here.  *COOKIE_SIZE is non-NULL if a cookie should
3430    be used.  If this function determines that no cookie should be
3431    used, after all, *COOKIE_SIZE is set to NULL_TREE.  If FN is
3432    non-NULL, it will be set, upon return, to the allocation function
3433    called.  */
3434
3435 tree
3436 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3437                          tree *size, tree *cookie_size,
3438                          tree *fn)
3439 {
3440   tree fns;
3441   struct z_candidate *candidates;
3442   struct z_candidate *cand;
3443   bool any_viable_p;
3444
3445   if (fn)
3446     *fn = NULL_TREE;
3447   VEC_safe_insert (tree, gc, *args, 0, *size);
3448   *args = resolve_args (*args);
3449   if (*args == NULL)
3450     return error_mark_node;
3451
3452   /* Based on:
3453
3454        [expr.new]
3455
3456        If this lookup fails to find the name, or if the allocated type
3457        is not a class type, the allocation function's name is looked
3458        up in the global scope.
3459
3460      we disregard block-scope declarations of "operator new".  */
3461   fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3462
3463   /* Figure out what function is being called.  */
3464   cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3465
3466   /* If no suitable function could be found, issue an error message
3467      and give up.  */
3468   if (!cand)
3469     {
3470       if (!any_viable_p)
3471         error ("no matching function for call to %<%D(%A)%>",
3472                DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3473       else
3474         error ("call of overloaded %<%D(%A)%> is ambiguous",
3475                DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3476       if (candidates)
3477         print_z_candidates (candidates);
3478       return error_mark_node;
3479     }
3480
3481    /* If a cookie is required, add some extra space.  Whether
3482       or not a cookie is required cannot be determined until
3483       after we know which function was called.  */
3484    if (*cookie_size)
3485      {
3486        bool use_cookie = true;
3487        if (!abi_version_at_least (2))
3488          {
3489            /* In G++ 3.2, the check was implemented incorrectly; it
3490               looked at the placement expression, rather than the
3491               type of the function.  */
3492            if (VEC_length (tree, *args) == 2
3493                && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3494                                ptr_type_node))
3495              use_cookie = false;
3496          }
3497        else
3498          {
3499            tree arg_types;
3500
3501            arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3502            /* Skip the size_t parameter.  */
3503            arg_types = TREE_CHAIN (arg_types);
3504            /* Check the remaining parameters (if any).  */
3505            if (arg_types
3506                && TREE_CHAIN (arg_types) == void_list_node
3507                && same_type_p (TREE_VALUE (arg_types),
3508                                ptr_type_node))
3509              use_cookie = false;
3510          }
3511        /* If we need a cookie, adjust the number of bytes allocated.  */
3512        if (use_cookie)
3513          {
3514            /* Update the total size.  */
3515            *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3516            /* Update the argument list to reflect the adjusted size.  */
3517            VEC_replace (tree, *args, 0, *size);
3518          }
3519        else
3520          *cookie_size = NULL_TREE;
3521      }
3522
3523    /* Tell our caller which function we decided to call.  */
3524    if (fn)
3525      *fn = cand->fn;
3526
3527    /* Build the CALL_EXPR.  */
3528    return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
3529 }
3530
3531 /* Build a new call to operator().  This may change ARGS.  */
3532
3533 tree
3534 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
3535 {