gcc/cp/call.c

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