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