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