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           && (TYPE_PTROB_P (type1)
2026               || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
2027         break;
2028       return;
2029
2030 /* 9 For every type T, there exist candidate operator functions of the form
2031              T*      operator+(T*);
2032
2033    10For  every  promoted arithmetic type T, there exist candidate operator
2034      functions of the form
2035              T       operator+(T);
2036              T       operator-(T);  */
2037
2038     case UNARY_PLUS_EXPR: /* unary + */
2039       if (TREE_CODE (type1) == POINTER_TYPE)
2040         break;
2041     case NEGATE_EXPR:
2042       if (ARITHMETIC_TYPE_P (type1))
2043         break;
2044       return;
2045
2046 /* 11For every promoted integral type T,  there  exist  candidate  operator
2047      functions of the form
2048              T       operator~(T);  */
2049
2050     case BIT_NOT_EXPR:
2051       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
2052         break;
2053       return;
2054
2055 /* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
2056      is the same type as C2 or is a derived class of C2, T  is  a  complete
2057      object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
2058      there exist candidate operator functions of the form
2059              CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
2060      where CV12 is the union of CV1 and CV2.  */
2061
2062     case MEMBER_REF:
2063       if (TREE_CODE (type1) == POINTER_TYPE
2064           && TYPE_PTR_TO_MEMBER_P (type2))
2065         {
2066           tree c1 = TREE_TYPE (type1);
2067           tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
2068
2069           if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
2070               && (TYPE_PTRMEMFUNC_P (type2)
2071                   || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
2072             break;
2073         }
2074       return;
2075
2076 /* 13For every pair of promoted arithmetic types L and R, there exist  can-
2077      didate operator functions of the form
2078              LR      operator*(L, R);
2079              LR      operator/(L, R);
2080              LR      operator+(L, R);
2081              LR      operator-(L, R);
2082              bool    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      where  LR  is  the  result of the usual arithmetic conversions between
2089      types L and R.
2090
2091    14For every pair of types T and I, where T  is  a  cv-qualified  or  cv-
2092      unqualified  complete  object  type and I is a promoted integral type,
2093      there exist candidate operator functions of the form
2094              T*      operator+(T*, I);
2095              T&      operator[](T*, I);
2096              T*      operator-(T*, I);
2097              T*      operator+(I, T*);
2098              T&      operator[](I, T*);
2099
2100    15For every T, where T is a pointer to complete object type, there exist
2101      candidate operator functions of the form112)
2102              ptrdiff_t operator-(T, T);
2103
2104    16For every pointer or enumeration type T, there exist candidate operator
2105      functions of the form
2106              bool    operator<(T, T);
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
2113    17For every pointer to member type T,  there  exist  candidate  operator
2114      functions of the form
2115              bool    operator==(T, T);
2116              bool    operator!=(T, T);  */
2117
2118     case MINUS_EXPR:
2119       if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
2120         break;
2121       if (TYPE_PTROB_P (type1)
2122           && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2123         {
2124           type2 = ptrdiff_type_node;
2125           break;
2126         }
2127     case MULT_EXPR:
2128     case TRUNC_DIV_EXPR:
2129       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2130         break;
2131       return;
2132
2133     case EQ_EXPR:
2134     case NE_EXPR:
2135       if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2136           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
2137         break;
2138       if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
2139         {
2140           type2 = type1;
2141           break;
2142         }
2143       if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
2144         {
2145           type1 = type2;
2146           break;
2147         }
2148       /* Fall through.  */
2149     case LT_EXPR:
2150     case GT_EXPR:
2151     case LE_EXPR:
2152     case GE_EXPR:
2153     case MAX_EXPR:
2154     case MIN_EXPR:
2155       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2156         break;
2157       if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2158         break;
2159       if (TREE_CODE (type1) == ENUMERAL_TYPE
2160           && TREE_CODE (type2) == ENUMERAL_TYPE)
2161         break;
2162       if (TYPE_PTR_P (type1)
2163           && null_ptr_cst_p (args[1])
2164           && !uses_template_parms (type1))
2165         {
2166           type2 = type1;
2167           break;
2168         }
2169       if (null_ptr_cst_p (args[0])
2170           && TYPE_PTR_P (type2)
2171           && !uses_template_parms (type2))
2172         {
2173           type1 = type2;
2174           break;
2175         }
2176       return;
2177
2178     case PLUS_EXPR:
2179       if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2180         break;
2181     case ARRAY_REF:
2182       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
2183         {
2184           type1 = ptrdiff_type_node;
2185           break;
2186         }
2187       if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2188         {
2189           type2 = ptrdiff_type_node;
2190           break;
2191         }
2192       return;
2193
2194 /* 18For  every pair of promoted integral types L and R, there exist candi-
2195      date operator functions of the form
2196              LR      operator%(L, R);
2197              LR      operator&(L, R);
2198              LR      operator^(L, R);
2199              LR      operator|(L, R);
2200              L       operator<<(L, R);
2201              L       operator>>(L, R);
2202      where LR is the result of the  usual  arithmetic  conversions  between
2203      types L and R.  */
2204
2205     case TRUNC_MOD_EXPR:
2206     case BIT_AND_EXPR:
2207     case BIT_IOR_EXPR:
2208     case BIT_XOR_EXPR:
2209     case LSHIFT_EXPR:
2210     case RSHIFT_EXPR:
2211       if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2212         break;
2213       return;
2214
2215 /* 19For  every  triple  L, VQ, R), where L is an arithmetic or enumeration
2216      type, VQ is either volatile or empty, and R is a  promoted  arithmetic
2217      type, there exist candidate operator functions of the form
2218              VQ L&   operator=(VQ L&, R);
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
2224    20For  every  pair T, VQ), where T is any type and VQ is either volatile
2225      or empty, there exist candidate operator functions of the form
2226              T*VQ&   operator=(T*VQ&, T*);
2227
2228    21For every pair T, VQ), where T is a pointer to member type and  VQ  is
2229      either  volatile or empty, there exist candidate operator functions of
2230      the form
2231              VQ T&   operator=(VQ T&, T);
2232
2233    22For every triple  T,  VQ,  I),  where  T  is  a  cv-qualified  or  cv-
2234      unqualified  complete object type, VQ is either volatile or empty, and
2235      I is a promoted integral type, there exist  candidate  operator  func-
2236      tions of the form
2237              T*VQ&   operator+=(T*VQ&, I);
2238              T*VQ&   operator-=(T*VQ&, I);
2239
2240    23For  every  triple  L,  VQ,  R), where L is an integral or enumeration
2241      type, VQ is either volatile or empty, and R  is  a  promoted  integral
2242      type, there exist candidate operator functions of the form
2243
2244              VQ L&   operator%=(VQ L&, R);
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
2251     case MODIFY_EXPR:
2252       switch (code2)
2253         {
2254         case PLUS_EXPR:
2255         case MINUS_EXPR:
2256           if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2257             {
2258               type2 = ptrdiff_type_node;
2259               break;
2260             }
2261         case MULT_EXPR:
2262         case TRUNC_DIV_EXPR:
2263           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2264             break;
2265           return;
2266
2267         case TRUNC_MOD_EXPR:
2268         case BIT_AND_EXPR:
2269         case BIT_IOR_EXPR:
2270         case BIT_XOR_EXPR:
2271         case LSHIFT_EXPR:
2272         case RSHIFT_EXPR:
2273           if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
2274             break;
2275           return;
2276
2277         case NOP_EXPR:
2278           if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
2279             break;
2280           if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
2281               || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2282               || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2283               || ((TYPE_PTRMEMFUNC_P (type1)
2284                    || TREE_CODE (type1) == POINTER_TYPE)
2285                   && null_ptr_cst_p (args[1])))
2286             {
2287               type2 = type1;
2288               break;
2289             }
2290           return;
2291
2292         default:
2293           gcc_unreachable ();
2294         }
2295       type1 = build_reference_type (type1);
2296       break;
2297
2298     case COND_EXPR:
2299       /* [over.built]
2300
2301          For every pair of promoted arithmetic types L and R, there
2302          exist candidate operator functions of the form
2303
2304          LR operator?(bool, L, R);
2305
2306          where LR is the result of the usual arithmetic conversions
2307          between types L and R.
2308
2309          For every type T, where T is a pointer or pointer-to-member
2310          type, there exist candidate operator functions of the form T
2311          operator?(bool, T, T);  */
2312
2313       if (promoted_arithmetic_type_p (type1)
2314           && promoted_arithmetic_type_p (type2))
2315         /* That's OK.  */
2316         break;
2317
2318       /* Otherwise, the types should be pointers.  */
2319       if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
2320           || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
2321         return;
2322
2323       /* We don't check that the two types are the same; the logic
2324          below will actually create two candidates; one in which both
2325          parameter types are TYPE1, and one in which both parameter
2326          types are TYPE2.  */
2327       break;
2328
2329     default:
2330       gcc_unreachable ();
2331     }
2332
2333   /* If we're dealing with two pointer types or two enumeral types,
2334      we need candidates for both of them.  */
2335   if (type2 && !same_type_p (type1, type2)
2336       && TREE_CODE (type1) == TREE_CODE (type2)
2337       && (TREE_CODE (type1) == REFERENCE_TYPE
2338           || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
2339           || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
2340           || TYPE_PTRMEMFUNC_P (type1)
2341           || MAYBE_CLASS_TYPE_P (type1)
2342           || TREE_CODE (type1) == ENUMERAL_TYPE))
2343     {
2344       build_builtin_candidate
2345         (candidates, fnname, type1, type1, args, argtypes, flags);
2346       build_builtin_candidate
2347         (candidates, fnname, type2, type2, args, argtypes, flags);
2348       return;
2349     }
2350
2351   build_builtin_candidate
2352     (candidates, fnname, type1, type2, args, argtypes, flags);
2353 }
2354
2355 tree
2356 type_decays_to (tree type)
2357 {
2358   if (TREE_CODE (type) == ARRAY_TYPE)
2359     return build_pointer_type (TREE_TYPE (type));
2360   if (TREE_CODE (type) == FUNCTION_TYPE)
2361     return build_pointer_type (type);
2362   if (!MAYBE_CLASS_TYPE_P (type))
2363     type = cv_unqualified (type);
2364   return type;
2365 }
2366
2367 /* There are three conditions of builtin candidates:
2368
2369    1) bool-taking candidates.  These are the same regardless of the input.
2370    2) pointer-pair taking candidates.  These are generated for each type
2371       one of the input types converts to.
2372    3) arithmetic candidates.  According to the standard, we should generate
2373       all of these, but I'm trying not to...
2374
2375    Here we generate a superset of the possible candidates for this particular
2376    case.  That is a subset of the full set the standard defines, plus some
2377    other cases which the standard disallows. add_builtin_candidate will
2378    filter out the invalid set.  */
2379
2380 static void
2381 add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2382                         enum tree_code code2, tree fnname, tree *args,
2383                         int flags)
2384 {
2385   int ref1, i;
2386   int enum_p = 0;
2387   tree type, argtypes[3], t;
2388   /* TYPES[i] is the set of possible builtin-operator parameter types
2389      we will consider for the Ith argument.  */
2390   VEC(tree,gc) *types[2];
2391   unsigned ix;
2392
2393   for (i = 0; i < 3; ++i)
2394     {
2395       if (args[i])
2396         argtypes[i] = unlowered_expr_type (args[i]);
2397       else
2398         argtypes[i] = NULL_TREE;
2399     }
2400
2401   switch (code)
2402     {
2403 /* 4 For every pair T, VQ), where T is an arithmetic or  enumeration  type,
2404      and  VQ  is  either  volatile or empty, there exist candidate operator
2405      functions of the form
2406                  VQ T&   operator++(VQ T&);  */
2407
2408     case POSTINCREMENT_EXPR:
2409     case PREINCREMENT_EXPR:
2410     case POSTDECREMENT_EXPR:
2411     case PREDECREMENT_EXPR:
2412     case MODIFY_EXPR:
2413       ref1 = 1;
2414       break;
2415
2416 /* 24There also exist candidate operator functions of the form
2417              bool    operator!(bool);
2418              bool    operator&&(bool, bool);
2419              bool    operator||(bool, bool);  */
2420
2421     case TRUTH_NOT_EXPR:
2422       build_builtin_candidate
2423         (candidates, fnname, boolean_type_node,
2424          NULL_TREE, args, argtypes, flags);
2425       return;
2426
2427     case TRUTH_ORIF_EXPR:
2428     case TRUTH_ANDIF_EXPR:
2429       build_builtin_candidate
2430         (candidates, fnname, boolean_type_node,
2431          boolean_type_node, args, argtypes, flags);
2432       return;
2433
2434     case ADDR_EXPR:
2435     case COMPOUND_EXPR:
2436     case COMPONENT_REF:
2437       return;
2438
2439     case COND_EXPR:
2440     case EQ_EXPR:
2441     case NE_EXPR:
2442     case LT_EXPR:
2443     case LE_EXPR:
2444     case GT_EXPR:
2445     case GE_EXPR:
2446       enum_p = 1;
2447       /* Fall through.  */
2448
2449     default:
2450       ref1 = 0;
2451     }
2452
2453   types[0] = make_tree_vector ();
2454   types[1] = make_tree_vector ();
2455
2456   for (i = 0; i < 2; ++i)
2457     {
2458       if (! args[i])
2459         ;
2460       else if (MAYBE_CLASS_TYPE_P (argtypes[i]))
2461         {
2462           tree convs;
2463
2464           if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2465             return;
2466
2467           convs = lookup_conversions (argtypes[i]);
2468
2469           if (code == COND_EXPR)
2470             {
2471               if (real_lvalue_p (args[i]))
2472                 VEC_safe_push (tree, gc, types[i],
2473                                build_reference_type (argtypes[i]));
2474
2475               VEC_safe_push (tree, gc, types[i],
2476                              TYPE_MAIN_VARIANT (argtypes[i]));
2477             }
2478
2479           else if (! convs)
2480             return;
2481
2482           for (; convs; convs = TREE_CHAIN (convs))
2483             {
2484               type = TREE_TYPE (convs);
2485
2486               if (i == 0 && ref1
2487                   && (TREE_CODE (type) != REFERENCE_TYPE
2488                       || CP_TYPE_CONST_P (TREE_TYPE (type))))
2489                 continue;
2490
2491               if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2492                 VEC_safe_push (tree, gc, types[i], type);
2493
2494               type = non_reference (type);
2495               if (i != 0 || ! ref1)
2496                 {
2497                   type = TYPE_MAIN_VARIANT (type_decays_to (type));
2498                   if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2499                     VEC_safe_push (tree, gc, types[i], type);
2500                   if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2501                     type = type_promotes_to (type);
2502                 }
2503
2504               if (! vec_member (type, types[i]))
2505                 VEC_safe_push (tree, gc, types[i], type);
2506             }
2507         }
2508       else
2509         {
2510           if (code == COND_EXPR && real_lvalue_p (args[i]))
2511             VEC_safe_push (tree, gc, types[i],
2512                            build_reference_type (argtypes[i]));
2513           type = non_reference (argtypes[i]);
2514           if (i != 0 || ! ref1)
2515             {
2516               type = TYPE_MAIN_VARIANT (type_decays_to (type));
2517               if (enum_p && UNSCOPED_ENUM_P (type))
2518                 VEC_safe_push (tree, gc, types[i], type);
2519               if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
2520                 type = type_promotes_to (type);
2521             }
2522           VEC_safe_push (tree, gc, types[i], type);
2523         }
2524     }
2525
2526   /* Run through the possible parameter types of both arguments,
2527      creating candidates with those parameter types.  */
2528   FOR_EACH_VEC_ELT_REVERSE (tree, types[0], ix, t)
2529     {
2530       unsigned jx;
2531       tree u;
2532
2533       if (!VEC_empty (tree, types[1]))
2534         FOR_EACH_VEC_ELT_REVERSE (tree, types[1], jx, u)
2535           add_builtin_candidate
2536             (candidates, code, code2, fnname, t,
2537              u, args, argtypes, flags);
2538       else
2539         add_builtin_candidate
2540           (candidates, code, code2, fnname, t,
2541            NULL_TREE, args, argtypes, flags);
2542     }
2543
2544   release_tree_vector (types[0]);
2545   release_tree_vector (types[1]);
2546 }
2547
2548
2549 /* If TMPL can be successfully instantiated as indicated by
2550    EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2551
2552    TMPL is the template.  EXPLICIT_TARGS are any explicit template
2553    arguments.  ARGLIST is the arguments provided at the call-site.
2554    This does not change ARGLIST.  The RETURN_TYPE is the desired type
2555    for conversion operators.  If OBJ is NULL_TREE, FLAGS and CTYPE are
2556    as for add_function_candidate.  If an OBJ is supplied, FLAGS and
2557    CTYPE are ignored, and OBJ is as for add_conv_candidate.  */
2558
2559 static struct z_candidate*
2560 add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2561                              tree ctype, tree explicit_targs, tree first_arg,
2562                              const VEC(tree,gc) *arglist, tree return_type,
2563                              tree access_path, tree conversion_path,
2564                              int flags, tree obj, unification_kind_t strict)
2565 {
2566   int ntparms = DECL_NTPARMS (tmpl);
2567   tree targs = make_tree_vec (ntparms);
2568   unsigned int len = VEC_length (tree, arglist);
2569   unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len;
2570   unsigned int skip_without_in_chrg = 0;
2571   tree first_arg_without_in_chrg = first_arg;
2572   tree *args_without_in_chrg;
2573   unsigned int nargs_without_in_chrg;
2574   unsigned int ia, ix;
2575   tree arg;
2576   struct z_candidate *cand;
2577   int i;
2578   tree fn;
2579
2580   /* We don't do deduction on the in-charge parameter, the VTT
2581      parameter or 'this'.  */
2582   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2583     {
2584       if (first_arg_without_in_chrg != NULL_TREE)
2585         first_arg_without_in_chrg = NULL_TREE;
2586       else
2587         ++skip_without_in_chrg;
2588     }
2589
2590   if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2591        || DECL_BASE_CONSTRUCTOR_P (tmpl))
2592       && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2593     {
2594       if (first_arg_without_in_chrg != NULL_TREE)
2595         first_arg_without_in_chrg = NULL_TREE;
2596       else
2597         ++skip_without_in_chrg;
2598     }
2599
2600   if (len < skip_without_in_chrg)
2601     return NULL;
2602
2603   nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0)
2604                            + (len - skip_without_in_chrg));
2605   args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg);
2606   ia = 0;
2607   if (first_arg_without_in_chrg != NULL_TREE)
2608     {
2609       args_without_in_chrg[ia] = first_arg_without_in_chrg;
2610       ++ia;
2611     }
2612   for (ix = skip_without_in_chrg;
2613        VEC_iterate (tree, arglist, ix, arg);
2614        ++ix)
2615     {
2616       args_without_in_chrg[ia] = arg;
2617       ++ia;
2618     }
2619   gcc_assert (ia == nargs_without_in_chrg);
2620
2621   i = fn_type_unification (tmpl, explicit_targs, targs,
2622                            args_without_in_chrg,
2623                            nargs_without_in_chrg,
2624                            return_type, strict, flags);
2625
2626   if (i != 0)
2627     goto fail;
2628
2629   fn = instantiate_template (tmpl, targs, tf_none);
2630   if (fn == error_mark_node)
2631     goto fail;
2632
2633   /* In [class.copy]:
2634
2635        A member function template is never instantiated to perform the
2636        copy of a class object to an object of its class type.
2637
2638      It's a little unclear what this means; the standard explicitly
2639      does allow a template to be used to copy a class.  For example,
2640      in:
2641
2642        struct A {
2643          A(A&);
2644          template <class T> A(const T&);
2645        };
2646        const A f ();
2647        void g () { A a (f ()); }
2648
2649      the member template will be used to make the copy.  The section
2650      quoted above appears in the paragraph that forbids constructors
2651      whose only parameter is (a possibly cv-qualified variant of) the
2652      class type, and a logical interpretation is that the intent was
2653      to forbid the instantiation of member templates which would then
2654      have that form.  */
2655   if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
2656     {
2657       tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2658       if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2659                                     ctype))
2660         goto fail;
2661     }
2662
2663   if (obj != NULL_TREE)
2664     /* Aha, this is a conversion function.  */
2665     cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist,
2666                                access_path, conversion_path);
2667   else
2668     cand = add_function_candidate (candidates, fn, ctype,
2669                                    first_arg, arglist, access_path,
2670                                    conversion_path, flags);
2671   if (DECL_TI_TEMPLATE (fn) != tmpl)
2672     /* This situation can occur if a member template of a template
2673        class is specialized.  Then, instantiate_template might return
2674        an instantiation of the specialization, in which case the
2675        DECL_TI_TEMPLATE field will point at the original
2676        specialization.  For example:
2677
2678          template <class T> struct S { template <class U> void f(U);
2679                                        template <> void f(int) {}; };
2680          S<double> sd;
2681          sd.f(3);
2682
2683        Here, TMPL will be template <class U> S<double>::f(U).
2684        And, instantiate template will give us the specialization
2685        template <> S<double>::f(int).  But, the DECL_TI_TEMPLATE field
2686        for this will point at template <class T> template <> S<T>::f(int),
2687        so that we can find the definition.  For the purposes of
2688        overload resolution, however, we want the original TMPL.  */
2689     cand->template_decl = build_template_info (tmpl, targs);
2690   else
2691     cand->template_decl = DECL_TEMPLATE_INFO (fn);
2692   cand->explicit_targs = explicit_targs;
2693
2694   return cand;
2695  fail:
2696   return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL,
2697                         access_path, conversion_path, 0);
2698 }
2699
2700
2701 static struct z_candidate *
2702 add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2703                         tree explicit_targs, tree first_arg,
2704                         const VEC(tree,gc) *arglist, tree return_type,
2705                         tree access_path, tree conversion_path, int flags,
2706                         unification_kind_t strict)
2707 {
2708   return
2709     add_template_candidate_real (candidates, tmpl, ctype,
2710                                  explicit_targs, first_arg, arglist,
2711                                  return_type, access_path, conversion_path,
2712                                  flags, NULL_TREE, strict);
2713 }
2714
2715
2716 static struct z_candidate *
2717 add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2718                              tree obj, tree first_arg,
2719                              const VEC(tree,gc) *arglist,
2720                              tree return_type, tree access_path,
2721                              tree conversion_path)
2722 {
2723   return
2724     add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2725                                  first_arg, arglist, return_type, access_path,
2726                                  conversion_path, 0, obj, DEDUCE_CONV);
2727 }
2728
2729 /* The CANDS are the set of candidates that were considered for
2730    overload resolution.  Return the set of viable candidates, or CANDS
2731    if none are viable.  If any of the candidates were viable, set
2732    *ANY_VIABLE_P to true.  STRICT_P is true if a candidate should be
2733    considered viable only if it is strictly viable.  */
2734
2735 static struct z_candidate*
2736 splice_viable (struct z_candidate *cands,
2737                bool strict_p,
2738                bool *any_viable_p)
2739 {
2740   struct z_candidate *viable;
2741   struct z_candidate **last_viable;
2742   struct z_candidate **cand;
2743
2744   viable = NULL;
2745   last_viable = &viable;
2746   *any_viable_p = false;
2747
2748   cand = &cands;
2749   while (*cand)
2750     {
2751       struct z_candidate *c = *cand;
2752       if (strict_p ? c->viable == 1 : c->viable)
2753         {
2754           *last_viable = c;
2755           *cand = c->next;
2756           c->next = NULL;
2757           last_viable = &c->next;
2758           *any_viable_p = true;
2759         }
2760       else
2761         cand = &c->next;
2762     }
2763
2764   return viable ? viable : cands;
2765 }
2766
2767 static bool
2768 any_strictly_viable (struct z_candidate *cands)
2769 {
2770   for (; cands; cands = cands->next)
2771     if (cands->viable == 1)
2772       return true;
2773   return false;
2774 }
2775
2776 /* OBJ is being used in an expression like "OBJ.f (...)".  In other
2777    words, it is about to become the "this" pointer for a member
2778    function call.  Take the address of the object.  */
2779
2780 static tree
2781 build_this (tree obj)
2782 {
2783   /* In a template, we are only concerned about the type of the
2784      expression, so we can take a shortcut.  */
2785   if (processing_template_decl)
2786     return build_address (obj);
2787
2788   return cp_build_addr_expr (obj, tf_warning_or_error);
2789 }
2790
2791 /* Returns true iff functions are equivalent. Equivalent functions are
2792    not '==' only if one is a function-local extern function or if
2793    both are extern "C".  */
2794
2795 static inline int
2796 equal_functions (tree fn1, tree fn2)
2797 {
2798   if (TREE_CODE (fn1) != TREE_CODE (fn2))
2799     return 0;
2800   if (TREE_CODE (fn1) == TEMPLATE_DECL)
2801     return fn1 == fn2;
2802   if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2803       || DECL_EXTERN_C_FUNCTION_P (fn1))
2804     return decls_match (fn1, fn2);
2805   return fn1 == fn2;
2806 }
2807
2808 /* Print information about one overload candidate CANDIDATE.  MSGSTR
2809    is the text to print before the candidate itself.
2810
2811    NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2812    to have been run through gettext by the caller.  This wart makes
2813    life simpler in print_z_candidates and for the translators.  */
2814
2815 static void
2816 print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2817 {
2818   if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2819     {
2820       if (candidate->num_convs == 3)
2821         inform (input_location, "%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2822                 candidate->convs[0]->type,
2823                 candidate->convs[1]->type,
2824                 candidate->convs[2]->type);
2825       else if (candidate->num_convs == 2)
2826         inform (input_location, "%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2827                 candidate->convs[0]->type,
2828                 candidate->convs[1]->type);
2829       else
2830         inform (input_location, "%s %D(%T) <built-in>", msgstr, candidate->fn,
2831                 candidate->convs[0]->type);
2832     }
2833   else if (TYPE_P (candidate->fn))
2834     inform (input_location, "%s %T <conversion>", msgstr, candidate->fn);
2835   else if (candidate->viable == -1)
2836     inform (input_location, "%s %+#D <near match>", msgstr, candidate->fn);
2837   else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn)))
2838     inform (input_location, "%s %+#D <deleted>", msgstr, candidate->fn);
2839   else
2840     inform (input_location, "%s %+#D", msgstr, candidate->fn);
2841 }
2842
2843 static void
2844 print_z_candidates (struct z_candidate *candidates)
2845 {
2846   const char *str;
2847   struct z_candidate *cand1;
2848   struct z_candidate **cand2;
2849   char *spaces;
2850
2851   if (!candidates)
2852     return;
2853
2854   /* Remove non-viable deleted candidates.  */
2855   cand1 = candidates;
2856   for (cand2 = &cand1; *cand2; )
2857     {
2858       if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2859           && !(*cand2)->viable
2860           && DECL_DELETED_FN ((*cand2)->fn))
2861         *cand2 = (*cand2)->next;
2862       else
2863         cand2 = &(*cand2)->next;
2864     }
2865   /* ...if there are any non-deleted ones.  */
2866   if (cand1)
2867     candidates = cand1;
2868
2869   /* There may be duplicates in the set of candidates.  We put off
2870      checking this condition as long as possible, since we have no way
2871      to eliminate duplicates from a set of functions in less than n^2
2872      time.  Now we are about to emit an error message, so it is more
2873      permissible to go slowly.  */
2874   for (cand1 = candidates; cand1; cand1 = cand1->next)
2875     {
2876       tree fn = cand1->fn;
2877       /* Skip builtin candidates and conversion functions.  */
2878       if (!DECL_P (fn))
2879         continue;
2880       cand2 = &cand1->next;
2881       while (*cand2)
2882         {
2883           if (DECL_P ((*cand2)->fn)
2884               && equal_functions (fn, (*cand2)->fn))
2885             *cand2 = (*cand2)->next;
2886           else
2887             cand2 = &(*cand2)->next;
2888         }
2889     }
2890
2891   str = candidates->next ? _("candidates are:") :  _("candidate is:");
2892   spaces = NULL;
2893   for (; candidates; candidates = candidates->next)
2894     {
2895       print_z_candidate (spaces ? spaces : str, candidates);
2896       spaces = spaces ? spaces : get_spaces (str);
2897     }
2898   free (spaces);
2899 }
2900
2901 /* USER_SEQ is a user-defined conversion sequence, beginning with a
2902    USER_CONV.  STD_SEQ is the standard conversion sequence applied to
2903    the result of the conversion function to convert it to the final
2904    desired type.  Merge the two sequences into a single sequence,
2905    and return the merged sequence.  */
2906
2907 static conversion *
2908 merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2909 {
2910   conversion **t;
2911
2912   gcc_assert (user_seq->kind == ck_user);
2913
2914   /* Find the end of the second conversion sequence.  */
2915   t = &(std_seq);
2916   while ((*t)->kind != ck_identity)
2917     t = &((*t)->u.next);
2918
2919   /* Replace the identity conversion with the user conversion
2920      sequence.  */
2921   *t = user_seq;
2922
2923   /* The entire sequence is a user-conversion sequence.  */
2924   std_seq->user_conv_p = true;
2925
2926   return std_seq;
2927 }
2928
2929 /* Handle overload resolution for initializing an object of class type from
2930    an initializer list.  First we look for a suitable constructor that
2931    takes a std::initializer_list; if we don't find one, we then look for a
2932    non-list constructor.
2933
2934    Parameters are as for add_candidates, except that the arguments are in
2935    the form of a CONSTRUCTOR (the initializer list) rather than a VEC, and
2936    the RETURN_TYPE parameter is replaced by TOTYPE, the desired type.  */
2937
2938 static void
2939 add_list_candidates (tree fns, tree first_arg,
2940                      tree init_list, tree totype,
2941                      tree explicit_targs, bool template_only,
2942                      tree conversion_path, tree access_path,
2943                      int flags,
2944                      struct z_candidate **candidates)
2945 {
2946   VEC(tree,gc) *args;
2947
2948   gcc_assert (*candidates == NULL);
2949
2950   /* For list-initialization we consider explicit constructors, but
2951      give an error if one is selected.  */
2952   flags &= ~LOOKUP_ONLYCONVERTING;
2953   /* And we don't allow narrowing conversions.  We also use this flag to
2954      avoid the copy constructor call for copy-list-initialization.  */
2955   flags |= LOOKUP_NO_NARROWING;
2956
2957   /* Always use the default constructor if the list is empty (DR 990).  */
2958   if (CONSTRUCTOR_NELTS (init_list) == 0
2959       && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype))
2960     ;
2961   /* If the class has a list ctor, try passing the list as a single
2962      argument first, but only consider list ctors.  */
2963   else if (TYPE_HAS_LIST_CTOR (totype))
2964     {
2965       flags |= LOOKUP_LIST_ONLY;
2966       args = make_tree_vector_single (init_list);
2967       add_candidates (fns, first_arg, args, NULL_TREE,
2968                       explicit_targs, template_only, conversion_path,
2969                       access_path, flags, candidates);
2970       if (any_strictly_viable (*candidates))
2971         return;
2972     }
2973
2974   args = ctor_to_vec (init_list);
2975
2976   /* We aren't looking for list-ctors anymore.  */
2977   flags &= ~LOOKUP_LIST_ONLY;
2978   /* We allow more user-defined conversions within an init-list.  */
2979   flags &= ~LOOKUP_NO_CONVERSION;
2980   /* But not for the copy ctor.  */
2981   flags |= LOOKUP_NO_COPY_CTOR_CONVERSION;
2982
2983   add_candidates (fns, first_arg, args, NULL_TREE,
2984                   explicit_targs, template_only, conversion_path,
2985                   access_path, flags, candidates);
2986 }
2987
2988 /* Returns the best overload candidate to perform the requested
2989    conversion.  This function is used for three the overloading situations
2990    described in [over.match.copy], [over.match.conv], and [over.match.ref].
2991    If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2992    per [dcl.init.ref], so we ignore temporary bindings.  */
2993
2994 static struct z_candidate *
2995 build_user_type_conversion_1 (tree totype, tree expr, int flags)
2996 {
2997   struct z_candidate *candidates, *cand;
2998   tree fromtype = TREE_TYPE (expr);
2999   tree ctors = NULL_TREE;
3000   tree conv_fns = NULL_TREE;
3001   conversion *conv = NULL;
3002   tree first_arg = NULL_TREE;
3003   VEC(tree,gc) *args = NULL;
3004   bool any_viable_p;
3005   int convflags;
3006
3007   /* We represent conversion within a hierarchy using RVALUE_CONV and
3008      BASE_CONV, as specified by [over.best.ics]; these become plain
3009      constructor calls, as specified in [dcl.init].  */
3010   gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype)
3011               || !DERIVED_FROM_P (totype, fromtype));
3012
3013   if (MAYBE_CLASS_TYPE_P (totype))
3014     ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
3015
3016   if (MAYBE_CLASS_TYPE_P (fromtype))
3017     {
3018       tree to_nonref = non_reference (totype);
3019       if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) ||
3020           (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype)
3021            && DERIVED_FROM_P (to_nonref, fromtype)))
3022         {
3023           /* [class.conv.fct] A conversion function is never used to
3024              convert a (possibly cv-qualified) object to the (possibly
3025              cv-qualified) same object type (or a reference to it), to a
3026              (possibly cv-qualified) base class of that type (or a
3027              reference to it)...  */
3028         }
3029       else
3030         conv_fns = lookup_conversions (fromtype);
3031     }
3032
3033   candidates = 0;
3034   flags |= LOOKUP_NO_CONVERSION;
3035   if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3036     flags |= LOOKUP_NO_NARROWING;
3037
3038   /* It's OK to bind a temporary for converting constructor arguments, but
3039      not in converting the return value of a conversion operator.  */
3040   convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION);
3041   flags &= ~LOOKUP_NO_TEMP_BIND;
3042
3043   if (ctors)
3044     {
3045       int ctorflags = flags;
3046       ctors = BASELINK_FUNCTIONS (ctors);
3047
3048       first_arg = build_int_cst (build_pointer_type (totype), 0);
3049
3050       /* We should never try to call the abstract or base constructor
3051          from here.  */
3052       gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
3053                   && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
3054
3055       if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3056         {
3057           /* List-initialization.  */
3058           add_list_candidates (ctors, first_arg, expr, totype, NULL_TREE,
3059                                false, TYPE_BINFO (totype), TYPE_BINFO (totype),
3060                                ctorflags, &candidates);
3061         }
3062       else
3063         {
3064           args = make_tree_vector_single (expr);
3065           add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false,
3066                           TYPE_BINFO (totype), TYPE_BINFO (totype),
3067                           ctorflags, &candidates);
3068         }
3069
3070       for (cand = candidates; cand; cand = cand->next)
3071         {
3072           cand->second_conv = build_identity_conv (totype, NULL_TREE);
3073
3074           /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't
3075              set, then this is copy-initialization.  In that case, "The
3076              result of the call is then used to direct-initialize the
3077              object that is the destination of the copy-initialization."
3078              [dcl.init]
3079
3080              We represent this in the conversion sequence with an
3081              rvalue conversion, which means a constructor call.  */
3082           if (TREE_CODE (totype) != REFERENCE_TYPE
3083               && !(convflags & LOOKUP_NO_TEMP_BIND))
3084             cand->second_conv
3085               = build_conv (ck_rvalue, totype, cand->second_conv);
3086         }
3087     }
3088
3089   if (conv_fns)
3090     first_arg = build_this (expr);
3091
3092   for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
3093     {
3094       tree conversion_path = TREE_PURPOSE (conv_fns);
3095       struct z_candidate *old_candidates;
3096
3097       /* If we are called to convert to a reference type, we are trying to
3098          find an lvalue binding, so don't even consider temporaries.  If
3099          we don't find an lvalue binding, the caller will try again to
3100          look for a temporary binding.  */
3101       if (TREE_CODE (totype) == REFERENCE_TYPE)
3102         convflags |= LOOKUP_NO_TEMP_BIND;
3103
3104       old_candidates = candidates;
3105       add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype,
3106                       NULL_TREE, false,
3107                       conversion_path, TYPE_BINFO (fromtype),
3108                       flags, &candidates);
3109
3110       for (cand = candidates; cand != old_candidates; cand = cand->next)
3111         {
3112           conversion *ics
3113             = implicit_conversion (totype,
3114                                    TREE_TYPE (TREE_TYPE (cand->fn)),
3115                                    0,
3116                                    /*c_cast_p=*/false, convflags);
3117
3118           /* If LOOKUP_NO_TEMP_BIND isn't set, then this is
3119              copy-initialization.  In that case, "The result of the
3120              call is then used to direct-initialize the object that is
3121              the destination of the copy-initialization."  [dcl.init]
3122
3123              We represent this in the conversion sequence with an
3124              rvalue conversion, which means a constructor call.  But
3125              don't add a second rvalue conversion if there's already
3126              one there.  Which there really shouldn't be, but it's
3127              harmless since we'd add it here anyway. */
3128           if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue
3129               && !(convflags & LOOKUP_NO_TEMP_BIND))
3130             ics = build_conv (ck_rvalue, totype, ics);
3131
3132           cand->second_conv = ics;
3133
3134           if (!ics)
3135             cand->viable = 0;
3136           else if (cand->viable == 1 && ics->bad_p)
3137             cand->viable = -1;
3138         }
3139     }
3140
3141   candidates = splice_viable (candidates, pedantic, &any_viable_p);
3142   if (!any_viable_p)
3143     return NULL;
3144
3145   cand = tourney (candidates);
3146   if (cand == 0)
3147     {
3148       if (flags & LOOKUP_COMPLAIN)
3149         {
3150           error ("conversion from %qT to %qT is ambiguous",
3151                     fromtype, totype);
3152           print_z_candidates (candidates);
3153         }
3154
3155       cand = candidates;        /* any one will do */
3156       cand->second_conv = build_ambiguous_conv (totype, expr);
3157       cand->second_conv->user_conv_p = true;
3158       if (!any_strictly_viable (candidates))
3159         cand->second_conv->bad_p = true;
3160       /* If there are viable candidates, don't set ICS_BAD_FLAG; an
3161          ambiguous conversion is no worse than another user-defined
3162          conversion.  */
3163
3164       return cand;
3165     }
3166
3167   /* Build the user conversion sequence.  */
3168   conv = build_conv
3169     (ck_user,
3170      (DECL_CONSTRUCTOR_P (cand->fn)
3171       ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
3172      build_identity_conv (TREE_TYPE (expr), expr));
3173   conv->cand = cand;
3174
3175   /* Remember that this was a list-initialization.  */
3176   if (flags & LOOKUP_NO_NARROWING)
3177     conv->check_narrowing = true;
3178
3179   /* Combine it with the second conversion sequence.  */
3180   cand->second_conv = merge_conversion_sequences (conv,
3181                                                   cand->second_conv);
3182
3183   if (cand->viable == -1)
3184     cand->second_conv->bad_p = true;
3185
3186   return cand;
3187 }
3188
3189 tree
3190 build_user_type_conversion (tree totype, tree expr, int flags)
3191 {
3192   struct z_candidate *cand
3193     = build_user_type_conversion_1 (totype, expr, flags);
3194
3195   if (cand)
3196     {
3197       if (cand->second_conv->kind == ck_ambig)
3198         return error_mark_node;
3199       expr = convert_like (cand->second_conv, expr, tf_warning_or_error);
3200       return convert_from_reference (expr);
3201     }
3202   return NULL_TREE;
3203 }
3204
3205 /* Subroutine of convert_nontype_argument.
3206
3207    EXPR is an argument for a template non-type parameter of integral or
3208    enumeration type.  Do any necessary conversions (that are permitted for
3209    non-type arguments) to convert it to the parameter type.
3210
3211    If conversion is successful, returns the converted expression;
3212    otherwise, returns error_mark_node.  */
3213
3214 tree
3215 build_integral_nontype_arg_conv (tree type, tree expr, tsubst_flags_t complain)
3216 {
3217   conversion *conv;
3218   void *p;
3219   tree t;
3220
3221   if (error_operand_p (expr))
3222     return error_mark_node;
3223
3224   gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
3225
3226   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3227   p = conversion_obstack_alloc (0);
3228
3229   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
3230                               /*c_cast_p=*/false,
3231                               LOOKUP_IMPLICIT);
3232
3233   /* for a non-type template-parameter of integral or
3234      enumeration type, integral promotions (4.5) and integral
3235      conversions (4.7) are applied.  */
3236   /* It should be sufficient to check the outermost conversion step, since
3237      there are no qualification conversions to integer type.  */
3238   if (conv)
3239     switch (conv->kind)
3240       {
3241         /* A conversion function is OK.  If it isn't constexpr, we'll
3242            complain later that the argument isn't constant.  */
3243       case ck_user:
3244         /* The lvalue-to-rvalue conversion is OK.  */
3245       case ck_rvalue:
3246       case ck_identity:
3247         break;
3248
3249       case ck_std:
3250         t = conv->u.next->type;
3251         if (INTEGRAL_OR_ENUMERATION_TYPE_P (t))
3252           break;
3253
3254         if (complain & tf_error)
3255           error ("conversion from %qT to %qT not considered for "
3256                  "non-type template argument", t, type);
3257         /* and fall through.  */
3258
3259       default:
3260         conv = NULL;
3261         break;
3262       }
3263
3264   if (conv)
3265     expr = convert_like (conv, expr, complain);
3266   else
3267     expr = error_mark_node;
3268
3269   /* Free all the conversions we allocated.  */
3270   obstack_free (&conversion_obstack, p);
3271
3272   return expr;
3273 }
3274
3275 /* Do any initial processing on the arguments to a function call.  */
3276
3277 static VEC(tree,gc) *
3278 resolve_args (VEC(tree,gc) *args)
3279 {
3280   unsigned int ix;
3281   tree arg;
3282
3283   FOR_EACH_VEC_ELT (tree, args, ix, arg)
3284     {
3285       if (error_operand_p (arg))
3286         return NULL;
3287       else if (VOID_TYPE_P (TREE_TYPE (arg)))
3288         {
3289           error ("invalid use of void expression");
3290           return NULL;
3291         }
3292       else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error))
3293         return NULL;
3294     }
3295   return args;
3296 }
3297
3298 /* Perform overload resolution on FN, which is called with the ARGS.
3299
3300    Return the candidate function selected by overload resolution, or
3301    NULL if the event that overload resolution failed.  In the case
3302    that overload resolution fails, *CANDIDATES will be the set of
3303    candidates considered, and ANY_VIABLE_P will be set to true or
3304    false to indicate whether or not any of the candidates were
3305    viable.
3306
3307    The ARGS should already have gone through RESOLVE_ARGS before this
3308    function is called.  */
3309
3310 static struct z_candidate *
3311 perform_overload_resolution (tree fn,
3312                              const VEC(tree,gc) *args,
3313                              struct z_candidate **candidates,
3314                              bool *any_viable_p)
3315 {
3316   struct z_candidate *cand;
3317   tree explicit_targs = NULL_TREE;
3318   int template_only = 0;
3319
3320   *candidates = NULL;
3321   *any_viable_p = true;
3322
3323   /* Check FN.  */
3324   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
3325               || TREE_CODE (fn) == TEMPLATE_DECL
3326               || TREE_CODE (fn) == OVERLOAD
3327               || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
3328
3329   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3330     {
3331       explicit_targs = TREE_OPERAND (fn, 1);
3332       fn = TREE_OPERAND (fn, 0);
3333       template_only = 1;
3334     }
3335
3336   /* Add the various candidate functions.  */
3337   add_candidates (fn, NULL_TREE, args, NULL_TREE,
3338                   explicit_targs, template_only,
3339                   /*conversion_path=*/NULL_TREE,
3340                   /*access_path=*/NULL_TREE,
3341                   LOOKUP_NORMAL,
3342                   candidates);
3343
3344   *candidates = splice_viable (*candidates, pedantic, any_viable_p);
3345   if (!*any_viable_p)
3346     return NULL;
3347
3348   cand = tourney (*candidates);
3349   return cand;
3350 }
3351
3352 /* Return an expression for a call to FN (a namespace-scope function,
3353    or a static member function) with the ARGS.  This may change
3354    ARGS.  */
3355
3356 tree
3357 build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p,
3358                          tsubst_flags_t complain)
3359 {
3360   struct z_candidate *candidates, *cand;
3361   bool any_viable_p;
3362   void *p;
3363   tree result;
3364
3365   if (args != NULL && *args != NULL)
3366     {
3367       *args = resolve_args (*args);
3368       if (*args == NULL)
3369         return error_mark_node;
3370     }
3371
3372   /* If this function was found without using argument dependent
3373      lookup, then we want to ignore any undeclared friend
3374      functions.  */
3375   if (!koenig_p)
3376     {
3377       tree orig_fn = fn;
3378
3379       fn = remove_hidden_names (fn);
3380       if (!fn)
3381         {
3382           if (complain & tf_error)
3383             error ("no matching function for call to %<%D(%A)%>",
3384                    DECL_NAME (OVL_CURRENT (orig_fn)),
3385                    build_tree_list_vec (*args));
3386           return error_mark_node;
3387         }
3388     }
3389
3390   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
3391   p = conversion_obstack_alloc (0);
3392
3393   cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p);
3394
3395   if (!cand)
3396     {
3397       if (complain & tf_error)
3398         {
3399           if (!any_viable_p && candidates && ! candidates->next
3400               && (TREE_CODE (candidates->fn) == FUNCTION_DECL))
3401             return cp_build_function_call_vec (candidates->fn, args, complain);
3402           if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3403             fn = TREE_OPERAND (fn, 0);
3404           if (!any_viable_p)
3405             error ("no matching function for call to %<%D(%A)%>",
3406                    DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3407           else
3408             error ("call of overloaded %<%D(%A)%> is ambiguous",
3409                    DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args));
3410           if (candidates)
3411             print_z_candidates (candidates);
3412         }
3413       result = error_mark_node;
3414     }
3415   else
3416     result = build_over_call (cand, LOOKUP_NORMAL, complain);
3417
3418   /* Free all the conversions we allocated.  */
3419   obstack_free (&conversion_obstack, p);
3420
3421   return result;
3422 }
3423
3424 /* Build a call to a global operator new.  FNNAME is the name of the
3425    operator (either "operator new" or "operator new[]") and ARGS are
3426    the arguments provided.  This may change ARGS.  *SIZE points to the
3427    total number of bytes required by the allocation, and is updated if
3428    that is changed here.  *COOKIE_SIZE is non-NULL if a cookie should
3429    be used.  If this function determines that no cookie should be
3430    used, after all, *COOKIE_SIZE is set to NULL_TREE.  If FN is
3431    non-NULL, it will be set, upon return, to the allocation function
3432    called.  */
3433
3434 tree
3435 build_operator_new_call (tree fnname, VEC(tree,gc) **args,
3436                          tree *size, tree *cookie_size,
3437                          tree *fn)
3438 {
3439   tree fns;
3440   struct z_candidate *candidates;
3441   struct z_candidate *cand;
3442   bool any_viable_p;
3443
3444   if (fn)
3445     *fn = NULL_TREE;
3446   VEC_safe_insert (tree, gc, *args, 0, *size);
3447   *args = resolve_args (*args);
3448   if (*args == NULL)
3449     return error_mark_node;
3450
3451   /* Based on:
3452
3453        [expr.new]
3454
3455        If this lookup fails to find the name, or if the allocated type
3456        is not a class type, the allocation function's name is looked
3457        up in the global scope.
3458
3459      we disregard block-scope declarations of "operator new".  */
3460   fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false);
3461
3462   /* Figure out what function is being called.  */
3463   cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p);
3464
3465   /* If no suitable function could be found, issue an error message
3466      and give up.  */
3467   if (!cand)
3468     {
3469       if (!any_viable_p)
3470         error ("no matching function for call to %<%D(%A)%>",
3471                DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3472       else
3473         error ("call of overloaded %<%D(%A)%> is ambiguous",
3474                DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args));
3475       if (candidates)
3476         print_z_candidates (candidates);
3477       return error_mark_node;
3478     }
3479
3480    /* If a cookie is required, add some extra space.  Whether
3481       or not a cookie is required cannot be determined until
3482       after we know which function was called.  */
3483    if (*cookie_size)
3484      {
3485        bool use_cookie = true;
3486        if (!abi_version_at_least (2))
3487          {
3488            /* In G++ 3.2, the check was implemented incorrectly; it
3489               looked at the placement expression, rather than the
3490               type of the function.  */
3491            if (VEC_length (tree, *args) == 2
3492                && same_type_p (TREE_TYPE (VEC_index (tree, *args, 1)),
3493                                ptr_type_node))
3494              use_cookie = false;
3495          }
3496        else
3497          {
3498            tree arg_types;
3499
3500            arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
3501            /* Skip the size_t parameter.  */
3502            arg_types = TREE_CHAIN (arg_types);
3503            /* Check the remaining parameters (if any).  */
3504            if (arg_types
3505                && TREE_CHAIN (arg_types) == void_list_node
3506                && same_type_p (TREE_VALUE (arg_types),
3507                                ptr_type_node))
3508              use_cookie = false;
3509          }
3510        /* If we need a cookie, adjust the number of bytes allocated.  */
3511        if (use_cookie)
3512          {
3513            /* Update the total size.  */
3514            *size = size_binop (PLUS_EXPR, *size, *cookie_size);
3515            /* Update the argument list to reflect the adjusted size.  */
3516            VEC_replace (tree, *args, 0, *size);
3517          }
3518        else
3519          *cookie_size = NULL_TREE;
3520      }
3521
3522    /* Tell our caller which function we decided to call.  */
3523    if (fn)
3524      *fn = cand->fn;
3525
3526    /* Build the CALL_EXPR.  */
3527    return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error);
3528 }
3529
3530 /* Build a new call to operator().  This may change ARGS.  */
3531
3532 tree
3533 build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
3534 {
3535   struct z_candidate *candidates = 0, *cand;
3536   tree&n