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