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