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, NULL_TREE);
 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                 /* If one of the arguments of the operator represents
4076                    an invalid use of member function pointer, try to report
4077                    a meaningful error ...  */
4078                 if (invalid_nonstatic_memfn_p (arg1, tf_error)
4079                     || invalid_nonstatic_memfn_p (arg2, tf_error)
4080                     || invalid_nonstatic_memfn_p (arg3, tf_error))
4081                   /* We displayed the error message.  */;
4082                 else
4083                   {
4084                     /* ... Otherwise, report the more generic
4085                        "no matching operator found" error */
4086                     op_error (code, code2, arg1, arg2, arg3, "no match");
4087                     print_z_candidates (candidates);
4088                   }
4089             }
4090           result = error_mark_node;
4091           break;
4092         }
4093     }
4094   else
4095     {
4096       cand = tourney (candidates);
4097       if (cand == 0)
4098         {
4099           if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
4100             {
4101               op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
4102               print_z_candidates (candidates);
4103             }
4104           result = error_mark_node;
4105         }
4106       else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
4107         {
4108           if (overloaded_p)
4109             *overloaded_p = true;
4110
4111           if (resolve_args (arglist) == error_mark_node)
4112             result = error_mark_node;
4113           else
4114             result = build_over_call (cand, LOOKUP_NORMAL, complain);
4115         }
4116       else
4117         {
4118           /* Give any warnings we noticed during overload resolution.  */
4119           if (cand->warnings && (complain & tf_warning))
4120             {
4121               struct candidate_warning *w;
4122               for (w = cand->warnings; w; w = w->next)
4123                 joust (cand, w->loser, 1);
4124             }
4125
4126           /* Check for comparison of different enum types.  */
4127           switch (code)
4128             {
4129             case GT_EXPR:
4130             case LT_EXPR:
4131             case GE_EXPR:
4132             case LE_EXPR:
4133             case EQ_EXPR:
4134             case NE_EXPR:
4135               if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
4136                   && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
4137                   && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
4138                       != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))
4139                   && (complain & tf_warning))
4140                 {
4141                   warning (OPT_Wenum_compare,
4142                            "comparison between %q#T and %q#T",
4143                            TREE_TYPE (arg1), TREE_TYPE (arg2));
4144                 }
4145               break;
4146             default:
4147               break;
4148             }
4149
4150           /* We need to strip any leading REF_BIND so that bitfields
4151              don't cause errors.  This should not remove any important
4152              conversions, because builtins don't apply to class
4153              objects directly.  */
4154           conv = cand->convs[0];
4155           if (conv->kind == ck_ref_bind)
4156             conv = conv->u.next;
4157           arg1 = convert_like (conv, arg1, complain);
4158
4159           if (arg2)
4160             {
4161               /* We need to call warn_logical_operator before
4162                  converting arg2 to a boolean_type.  */
4163               if (complain & tf_warning)
4164                 warn_logical_operator (input_location, code,
4165                                        code_orig_arg1, arg1,
4166                                        code_orig_arg2, arg2);
4167
4168               conv = cand->convs[1];
4169               if (conv->kind == ck_ref_bind)
4170                 conv = conv->u.next;
4171               arg2 = convert_like (conv, arg2, complain);
4172             }
4173           if (arg3)
4174             {
4175               conv = cand->convs[2];
4176               if (conv->kind == ck_ref_bind)
4177                 conv = conv->u.next;
4178               arg3 = convert_like (conv, arg3, complain);
4179             }
4180
4181         }
4182     }
4183
4184  user_defined_result_ready:
4185
4186   /* Free all the conversions we allocated.  */
4187   obstack_free (&conversion_obstack, p);
4188
4189   if (result || result_valid_p)
4190     return result;
4191
4192  builtin:
4193   switch (code)
4194     {
4195     case MODIFY_EXPR:
4196       return cp_build_modify_expr (arg1, code2, arg2, complain);
4197
4198     case INDIRECT_REF:
4199       return cp_build_indirect_ref (arg1, "unary *", complain);
4200
4201     case TRUTH_ANDIF_EXPR:
4202     case TRUTH_ORIF_EXPR:
4203     case TRUTH_AND_EXPR:
4204     case TRUTH_OR_EXPR:
4205       warn_logical_operator (input_location, code,
4206                              code_orig_arg1, arg1, code_orig_arg2, arg2);
4207       /* Fall through.  */
4208     case PLUS_EXPR:
4209     case MINUS_EXPR:
4210     case MULT_EXPR:
4211     case TRUNC_DIV_EXPR:
4212     case GT_EXPR:
4213     case LT_EXPR:
4214     case GE_EXPR:
4215     case LE_EXPR:
4216     case EQ_EXPR:
4217     case NE_EXPR:
4218     case MAX_EXPR:
4219     case MIN_EXPR:
4220     case LSHIFT_EXPR:
4221     case RSHIFT_EXPR:
4222     case TRUNC_MOD_EXPR:
4223     case BIT_AND_EXPR:
4224     case BIT_IOR_EXPR:
4225     case BIT_XOR_EXPR:
4226       return cp_build_binary_op (input_location, code, arg1, arg2, complain);
4227
4228     case UNARY_PLUS_EXPR:
4229     case NEGATE_EXPR:
4230     case BIT_NOT_EXPR:
4231     case TRUTH_NOT_EXPR:
4232     case PREINCREMENT_EXPR:
4233     case POSTINCREMENT_EXPR:
4234     case PREDECREMENT_EXPR:
4235     case POSTDECREMENT_EXPR:
4236     case REALPART_EXPR:
4237     case IMAGPART_EXPR:
4238       return cp_build_unary_op (code, arg1, candidates != 0, complain);
4239
4240     case ARRAY_REF:
4241       return build_array_ref (arg1, arg2, input_location);
4242
4243     case COND_EXPR:
4244       return build_conditional_expr (arg1, arg2, arg3, complain);
4245
4246     case MEMBER_REF:
4247       return build_m_component_ref (cp_build_indirect_ref (arg1, NULL,
4248                                                            complain),
4249                                     arg2);
4250
4251       /* The caller will deal with these.  */
4252     case ADDR_EXPR:
4253     case COMPONENT_REF:
4254     case COMPOUND_EXPR:
4255       return NULL_TREE;
4256
4257     default:
4258       gcc_unreachable ();
4259     }
4260   return NULL_TREE;
4261 }
4262
4263 /* Build a call to operator delete.  This has to be handled very specially,
4264    because the restrictions on what signatures match are different from all
4265    other call instances.  For a normal delete, only a delete taking (void *)
4266    or (void *, size_t) is accepted.  For a placement delete, only an exact
4267    match with the placement new is accepted.
4268
4269    CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
4270    ADDR is the pointer to be deleted.
4271    SIZE is the size of the memory block to be deleted.
4272    GLOBAL_P is true if the delete-expression should not consider
4273    class-specific delete operators.
4274    PLACEMENT is the corresponding placement new call, or NULL_TREE.
4275
4276    If this call to "operator delete" is being generated as part to
4277    deallocate memory allocated via a new-expression (as per [expr.new]
4278    which requires that if the initialization throws an exception then
4279    we call a deallocation function), then ALLOC_FN is the allocation
4280    function.  */
4281
4282 tree
4283 build_op_delete_call (enum tree_code code, tree addr, tree size,
4284                       bool global_p, tree placement,
4285                       tree alloc_fn)
4286 {
4287   tree fn = NULL_TREE;
4288   tree fns, fnname, argtypes, type;
4289   int pass;
4290
4291   if (addr == error_mark_node)
4292     return error_mark_node;
4293
4294   type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4295
4296   fnname = ansi_opname (code);
4297
4298   if (CLASS_TYPE_P (type)
4299       && COMPLETE_TYPE_P (complete_type (type))
4300       && !global_p)
4301     /* In [class.free]
4302
4303        If the result of the lookup is ambiguous or inaccessible, or if
4304        the lookup selects a placement deallocation function, the
4305        program is ill-formed.
4306
4307        Therefore, we ask lookup_fnfields to complain about ambiguity.  */
4308     {
4309       fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4310       if (fns == error_mark_node)
4311         return error_mark_node;
4312     }
4313   else
4314     fns = NULL_TREE;
4315
4316   if (fns == NULL_TREE)
4317     fns = lookup_name_nonclass (fnname);
4318
4319   /* Strip const and volatile from addr.  */
4320   addr = cp_convert (ptr_type_node, addr);
4321
4322   if (placement)
4323     {
4324       /* Get the parameter types for the allocation function that is
4325          being called.  */
4326       gcc_assert (alloc_fn != NULL_TREE);
4327       argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4328     }
4329   else
4330     {
4331       /* First try it without the size argument.  */
4332       argtypes = void_list_node;
4333     }
4334
4335   /* We make two tries at finding a matching `operator delete'.  On
4336      the first pass, we look for a one-operator (or placement)
4337      operator delete.  If we're not doing placement delete, then on
4338      the second pass we look for a two-argument delete.  */
4339   for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4340     {
4341       /* Go through the `operator delete' functions looking for one
4342          with a matching type.  */
4343       for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4344            fn;
4345            fn = OVL_NEXT (fn))
4346         {
4347           tree t;
4348
4349           /* The first argument must be "void *".  */
4350           t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4351           if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4352             continue;
4353           t = TREE_CHAIN (t);
4354           /* On the first pass, check the rest of the arguments.  */
4355           if (pass == 0)
4356             {
4357               tree a = argtypes;
4358               while (a && t)
4359                 {
4360                   if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4361                     break;
4362                   a = TREE_CHAIN (a);
4363                   t = TREE_CHAIN (t);
4364                 }
4365               if (!a && !t)
4366                 break;
4367             }
4368           /* On the second pass, look for a function with exactly two
4369              arguments: "void *" and "size_t".  */
4370           else if (pass == 1
4371                    /* For "operator delete(void *, ...)" there will be
4372                       no second argument, but we will not get an exact
4373                       match above.  */
4374                    && t
4375                    && same_type_p (TREE_VALUE (t), size_type_node)
4376                    && TREE_CHAIN (t) == void_list_node)
4377             break;
4378         }
4379
4380       /* If we found a match, we're done.  */
4381       if (fn)
4382         break;
4383     }
4384
4385   /* If we have a matching function, call it.  */
4386   if (fn)
4387     {
4388       /* Make sure we have the actual function, and not an
4389          OVERLOAD.  */
4390       fn = OVL_CURRENT (fn);
4391
4392       /* If the FN is a member function, make sure that it is
4393          accessible.  */
4394       if (DECL_CLASS_SCOPE_P (fn))
4395         perform_or_defer_access_check (TYPE_BINFO (type), fn, fn);
4396
4397       if (placement)
4398         {
4399           /* The placement args might not be suitable for overload
4400              resolution at this point, so build the call directly.  */
4401           int nargs = call_expr_nargs (placement);
4402           tree *argarray = (tree *) alloca (nargs * sizeof (tree));
4403           int i;
4404           argarray[0] = addr;
4405           for (i = 1; i < nargs; i++)
4406             argarray[i] = CALL_EXPR_ARG (placement, i);
4407           mark_used (fn);
4408           return build_cxx_call (fn, nargs, argarray);
4409         }
4410       else
4411         {
4412           tree args;
4413           if (pass == 0)
4414             args = tree_cons (NULL_TREE, addr, NULL_TREE);
4415           else
4416             args = tree_cons (NULL_TREE, addr,
4417                               build_tree_list (NULL_TREE, size));
4418           return cp_build_function_call (fn, args, tf_warning_or_error);
4419         }
4420     }
4421
4422   /* [expr.new]
4423
4424      If no unambiguous matching deallocation function can be found,
4425      propagating the exception does not cause the object's memory to
4426      be freed.  */
4427   if (alloc_fn)
4428     {
4429       if (!placement)
4430         warning (0, "no corresponding deallocation function for %qD",
4431                  alloc_fn);
4432       return NULL_TREE;
4433     }
4434
4435   error ("no suitable %<operator %s%> for %qT",
4436          operator_name_info[(int)code].name, type);
4437   return error_mark_node;
4438 }
4439
4440 /* If the current scope isn't allowed to access DECL along
4441    BASETYPE_PATH, give an error.  The most derived class in
4442    BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4443    the declaration to use in the error diagnostic.  */
4444
4445 bool
4446 enforce_access (tree basetype_path, tree decl, tree diag_decl)
4447 {
4448   gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4449
4450   if (!accessible_p (basetype_path, decl, true))
4451     {
4452       if (TREE_PRIVATE (decl))
4453         error ("%q+#D is private", diag_decl);
4454       else if (TREE_PROTECTED (decl))
4455         error ("%q+#D is protected", diag_decl);
4456       else
4457         error ("%q+#D is inaccessible", diag_decl);
4458       error ("within this context");
4459       return false;
4460     }
4461
4462   return true;
4463 }
4464
4465 /* Initialize a temporary of type TYPE with EXPR.  The FLAGS are a
4466    bitwise or of LOOKUP_* values.  If any errors are warnings are
4467    generated, set *DIAGNOSTIC_FN to "error" or "warning",
4468    respectively.  If no diagnostics are generated, set *DIAGNOSTIC_FN
4469    to NULL.  */
4470
4471 static tree
4472 build_temp (tree expr, tree type, int flags,
4473             diagnostic_t *diagnostic_kind)
4474 {
4475   int savew, savee;
4476
4477   savew = warningcount, savee = errorcount;
4478   expr = build_special_member_call (NULL_TREE,
4479                                     complete_ctor_identifier,
4480                                     build_tree_list (NULL_TREE, expr),
4481                                     type, flags, tf_warning_or_error);
4482   if (warningcount > savew)
4483     *diagnostic_kind = DK_WARNING;
4484   else if (errorcount > savee)
4485     *diagnostic_kind = DK_ERROR;
4486   else
4487     *diagnostic_kind = DK_UNSPECIFIED;
4488   return expr;
4489 }
4490
4491 /* Perform warnings about peculiar, but valid, conversions from/to NULL.
4492    EXPR is implicitly converted to type TOTYPE.
4493    FN and ARGNUM are used for diagnostics.  */
4494
4495 static void
4496 conversion_null_warnings (tree totype, tree expr, tree fn, int argnum)
4497 {
4498   tree t = non_reference (totype);
4499
4500   /* Issue warnings about peculiar, but valid, uses of NULL.  */
4501   if (expr == null_node && TREE_CODE (t) != BOOLEAN_TYPE && ARITHMETIC_TYPE_P (t))
4502     {
4503       if (fn)
4504         warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD",
4505                  argnum, fn);
4506       else
4507         warning (OPT_Wconversion, "converting to non-pointer type %qT from NULL", t);
4508     }
4509
4510   /* Issue warnings if "false" is converted to a NULL pointer */
4511   else if (expr == boolean_false_node && fn && POINTER_TYPE_P (t))
4512     warning (OPT_Wconversion,
4513              "converting %<false%> to pointer type for argument %P of %qD",
4514              argnum, fn);
4515 }
4516
4517 /* Perform the conversions in CONVS on the expression EXPR.  FN and
4518    ARGNUM are used for diagnostics.  ARGNUM is zero based, -1
4519    indicates the `this' argument of a method.  INNER is nonzero when
4520    being called to continue a conversion chain. It is negative when a
4521    reference binding will be applied, positive otherwise.  If
4522    ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4523    conversions will be emitted if appropriate.  If C_CAST_P is true,
4524    this conversion is coming from a C-style cast; in that case,
4525    conversions to inaccessible bases are permitted.  */
4526
4527 static tree
4528 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4529                    int inner, bool issue_conversion_warnings,
4530                    bool c_cast_p, tsubst_flags_t complain)
4531 {
4532   tree totype = convs->type;
4533   diagnostic_t diag_kind;
4534   int flags;
4535
4536   if (convs->bad_p
4537       && convs->kind != ck_user
4538       && convs->kind != ck_ambig
4539       && convs->kind != ck_ref_bind
4540       && convs->kind != ck_rvalue
4541       && convs->kind != ck_base)
4542     {
4543       conversion *t = convs;
4544       for (; t; t = convs->u.next)
4545         {
4546           if (t->kind == ck_user || !t->bad_p)
4547             {
4548               expr = convert_like_real (t, expr, fn, argnum, 1,
4549                                         /*issue_conversion_warnings=*/false,
4550                                         /*c_cast_p=*/false,
4551                                         complain);
4552               break;
4553             }
4554           else if (t->kind == ck_ambig)
4555             return convert_like_real (t, expr, fn, argnum, 1,
4556                                       /*issue_conversion_warnings=*/false,
4557                                       /*c_cast_p=*/false,
4558                                       complain);
4559           else if (t->kind == ck_identity)
4560             break;
4561         }
4562       if (complain & tf_error)
4563         {
4564           permerror (input_location, "invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4565           if (fn)
4566             permerror (input_location, "  initializing argument %P of %qD", argnum, fn);
4567         }
4568       else
4569         return error_mark_node;
4570
4571       return cp_convert (totype, expr);
4572     }
4573
4574   if (issue_conversion_warnings && (complain & tf_warning))
4575     conversion_null_warnings (totype, expr, fn, argnum);
4576
4577   switch (convs->kind)
4578     {
4579     case ck_user:
4580       {
4581         struct z_candidate *cand = convs->cand;
4582         tree convfn = cand->fn;
4583         unsigned i;
4584
4585         /* When converting from an init list we consider explicit
4586            constructors, but actually trying to call one is an error.  */
4587         if (DECL_NONCONVERTING_P (convfn))
4588           {
4589             if (complain & tf_error)
4590               error ("converting to %qT from initializer list would use "
4591                      "explicit constructor %qD", totype, convfn);
4592             else
4593               return error_mark_node;
4594           }
4595
4596         /* Set user_conv_p on the argument conversions, so rvalue/base
4597            handling knows not to allow any more UDCs.  */
4598         for (i = 0; i < cand->num_convs; ++i)
4599           cand->convs[i]->user_conv_p = true;
4600
4601         expr = build_over_call (cand, LOOKUP_NORMAL, complain);
4602
4603         /* If this is a constructor or a function returning an aggr type,
4604            we need to build up a TARGET_EXPR.  */
4605         if (DECL_CONSTRUCTOR_P (convfn))
4606           {
4607             expr = build_cplus_new (totype, expr);
4608
4609             /* Remember that this was list-initialization.  */
4610             if (convs->check_narrowing)
4611               TARGET_EXPR_LIST_INIT_P (expr) = true;
4612           }
4613
4614         return expr;
4615       }
4616     case ck_identity:
4617       if (type_unknown_p (expr))
4618         expr = instantiate_type (totype, expr, complain);
4619       /* Convert a constant to its underlying value, unless we are
4620          about to bind it to a reference, in which case we need to
4621          leave it as an lvalue.  */
4622       if (inner >= 0)
4623         {
4624           expr = decl_constant_value (expr);
4625           if (expr == null_node && INTEGRAL_TYPE_P (totype))
4626             /* If __null has been converted to an integer type, we do not
4627                want to warn about uses of EXPR as an integer, rather than
4628                as a pointer.  */
4629             expr = build_int_cst (totype, 0);
4630         }
4631       return expr;
4632     case ck_ambig:
4633       /* Call build_user_type_conversion again for the error.  */
4634       return build_user_type_conversion
4635         (totype, convs->u.expr, LOOKUP_NORMAL);
4636
4637     case ck_list:
4638       {
4639         /* Conversion to std::initializer_list<T>.  */
4640         tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0);
4641         tree new_ctor = build_constructor (init_list_type_node, NULL);
4642         unsigned len = CONSTRUCTOR_NELTS (expr);
4643         tree array, parms, val;
4644         unsigned ix;
4645
4646         /* Convert all the elements.  */
4647         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val)
4648           {
4649             tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum,
4650                                           1, false, false, complain);
4651             if (sub == error_mark_node)
4652               return sub;
4653             check_narrowing (TREE_TYPE (sub), val);
4654             CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub);
4655           }
4656         /* Build up the array.  */
4657         elttype = cp_build_qualified_type
4658           (elttype, TYPE_QUALS (elttype) | TYPE_QUAL_CONST);
4659         array = build_array_of_n_type (elttype, len);
4660         array = finish_compound_literal (array, new_ctor);
4661
4662         parms = build_tree_list (NULL_TREE, size_int (len));
4663         parms = tree_cons (NULL_TREE, decay_conversion (array), parms);
4664         /* Call the private constructor.  */
4665         push_deferring_access_checks (dk_no_check);
4666         new_ctor = build_special_member_call
4667           (NULL_TREE, complete_ctor_identifier, parms, totype, 0, complain);
4668         pop_deferring_access_checks ();
4669         return build_cplus_new (totype, new_ctor);
4670       }
4671
4672     case ck_aggr:
4673       return get_target_expr (digest_init (totype, expr));
4674
4675     default:
4676       break;
4677     };
4678
4679   expr = convert_like_real (convs->u.next, expr, fn, argnum,
4680                             convs->kind == ck_ref_bind ? -1 : 1,
4681                             convs->kind == ck_ref_bind ? issue_conversion_warnings : false,
4682                             c_cast_p,
4683                             complain);
4684   if (expr == error_mark_node)
4685     return error_mark_node;
4686
4687   switch (convs->kind)
4688     {
4689     case ck_rvalue:
4690       expr = convert_bitfield_to_declared_type (expr);
4691       if (! MAYBE_CLASS_TYPE_P (totype))
4692         return expr;
4693       /* Else fall through.  */
4694     case ck_base:
4695       if (convs->kind == ck_base && !convs->need_temporary_p)
4696         {
4697           /* We are going to bind a reference directly to a base-class
4698              subobject of EXPR.  */
4699           /* Build an expression for `*((base*) &expr)'.  */
4700           expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
4701           expr = convert_to_base (expr, build_pointer_type (totype),
4702                                   !c_cast_p, /*nonnull=*/true);
4703           expr = cp_build_indirect_ref (expr, "implicit conversion", complain);
4704           return expr;
4705         }
4706
4707       /* Copy-initialization where the cv-unqualified version of the source
4708          type is the same class as, or a derived class of, the class of the
4709          destination [is treated as direct-initialization].  [dcl.init] */
4710       flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING;
4711       if (convs->user_conv_p)
4712         /* This conversion is being done in the context of a user-defined
4713            conversion (i.e. the second step of copy-initialization), so
4714            don't allow any more.  */
4715         flags |= LOOKUP_NO_CONVERSION;
4716       expr = build_temp (expr, totype, flags, &diag_kind);
4717       if (diag_kind && fn)
4718         {
4719           if ((complain & tf_error))
4720             emit_diagnostic (diag_kind, input_location, 0,
4721                              "  initializing argument %P of %qD", argnum, fn);
4722           else if (diag_kind == DK_ERROR)
4723             return error_mark_node;
4724         }
4725       return build_cplus_new (totype, expr);
4726
4727     case ck_ref_bind:
4728       {
4729         tree ref_type = totype;
4730
4731         /* If necessary, create a temporary.
4732
4733            VA_ARG_EXPR and CONSTRUCTOR expressions are special cases
4734            that need temporaries, even when their types are reference
4735            compatible with the type of reference being bound, so the
4736            upcoming call to cp_build_unary_op (ADDR_EXPR, expr, ...)
4737            doesn't fail.  */
4738         if (convs->need_temporary_p
4739             || TREE_CODE (expr) == CONSTRUCTOR
4740             || TREE_CODE (expr) == VA_ARG_EXPR)
4741           {
4742             tree type = convs->u.next->type;
4743             cp_lvalue_kind lvalue = real_lvalue_p (expr);
4744
4745             if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))
4746                 && !TYPE_REF_IS_RVALUE (ref_type))
4747               {
4748                 if (complain & tf_error)
4749                   {
4750                     /* If the reference is volatile or non-const, we
4751                        cannot create a temporary.  */
4752                     if (lvalue & clk_bitfield)
4753                       error ("cannot bind bitfield %qE to %qT",
4754                              expr, ref_type);
4755                     else if (lvalue & clk_packed)
4756                       error ("cannot bind packed field %qE to %qT",
4757                              expr, ref_type);
4758                     else
4759                       error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4760                   }
4761                 return error_mark_node;
4762               }
4763             /* If the source is a packed field, and we must use a copy
4764                constructor, then building the target expr will require
4765                binding the field to the reference parameter to the
4766                copy constructor, and we'll end up with an infinite
4767                loop.  If we can use a bitwise copy, then we'll be
4768                OK.  */
4769             if ((lvalue & clk_packed)
4770                 && CLASS_TYPE_P (type)
4771                 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4772               {
4773                 if (complain & tf_error)
4774                   error ("cannot bind packed field %qE to %qT",
4775                          expr, ref_type);
4776                 return error_mark_node;
4777               }
4778             if (lvalue & clk_bitfield)
4779               {
4780                 expr = convert_bitfield_to_declared_type (expr);
4781                 expr = fold_convert (type, expr);
4782               }
4783             expr = build_target_expr_with_type (expr, type);
4784           }
4785
4786         /* Take the address of the thing to which we will bind the
4787            reference.  */
4788         expr = cp_build_unary_op (ADDR_EXPR, expr, 1, complain);
4789         if (expr == error_mark_node)
4790           return error_mark_node;
4791
4792         /* Convert it to a pointer to the type referred to by the
4793            reference.  This will adjust the pointer if a derived to
4794            base conversion is being performed.  */
4795         expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4796                            expr);
4797         /* Convert the pointer to the desired reference type.  */
4798         return build_nop (ref_type, expr);
4799       }
4800
4801     case ck_lvalue:
4802       return decay_conversion (expr);
4803
4804     case ck_qual:
4805       /* Warn about deprecated conversion if appropriate.  */
4806       string_conv_p (totype, expr, 1);
4807       break;
4808
4809     case ck_ptr:
4810       if (convs->base_p)
4811         expr = convert_to_base (expr, totype, !c_cast_p,
4812                                 /*nonnull=*/false);
4813       return build_nop (totype, expr);
4814
4815     case ck_pmem:
4816       return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4817                              c_cast_p);
4818
4819     default:
4820       break;
4821     }
4822
4823   if (convs->check_narrowing)
4824     check_narrowing (totype, expr);
4825
4826   if (issue_conversion_warnings && (complain & tf_warning))
4827     expr = convert_and_check (totype, expr);
4828   else
4829     expr = convert (totype, expr);
4830
4831   return expr;
4832 }
4833
4834 /* Build a call to __builtin_trap.  */
4835
4836 static tree
4837 call_builtin_trap (void)
4838 {
4839   tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4840
4841   gcc_assert (fn != NULL);
4842   fn = build_call_n (fn, 0);
4843   return fn;
4844 }
4845
4846 /* ARG is being passed to a varargs function.  Perform any conversions
4847    required.  Return the converted value.  */
4848
4849 tree
4850 convert_arg_to_ellipsis (tree arg)
4851 {
4852   /* [expr.call]
4853
4854      The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4855      standard conversions are performed.  */
4856   arg = decay_conversion (arg);
4857   /* [expr.call]
4858
4859      If the argument has integral or enumeration type that is subject
4860      to the integral promotions (_conv.prom_), or a floating point
4861      type that is subject to the floating point promotion
4862      (_conv.fpprom_), the value of the argument is converted to the
4863      promoted type before the call.  */
4864   if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4865       && (TYPE_PRECISION (TREE_TYPE (arg))
4866           < TYPE_PRECISION (double_type_node)))
4867     arg = convert_to_real (double_type_node, arg);
4868   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4869     arg = perform_integral_promotions (arg);
4870
4871   arg = require_complete_type (arg);
4872
4873   if (arg != error_mark_node
4874       && !pod_type_p (TREE_TYPE (arg)))
4875     {
4876       /* Undefined behavior [expr.call] 5.2.2/7.  We used to just warn
4877          here and do a bitwise copy, but now cp_expr_size will abort if we
4878          try to do that.
4879          If the call appears in the context of a sizeof expression,
4880          there is no need to emit a warning, since the expression won't be
4881          evaluated. We keep the builtin_trap just as a safety check.  */
4882       if (!skip_evaluation)
4883         warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
4884                  "call will abort at runtime", TREE_TYPE (arg));
4885       arg = call_builtin_trap ();
4886       arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4887                     integer_zero_node);
4888     }
4889
4890   return arg;
4891 }
4892
4893 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused.  */
4894
4895 tree
4896 build_x_va_arg (tree expr, tree type)
4897 {
4898   if (processing_template_decl)
4899     return build_min (VA_ARG_EXPR, type, expr);
4900
4901   type = complete_type_or_else (type, NULL_TREE);
4902
4903   if (expr == error_mark_node || !type)
4904     return error_mark_node;
4905
4906   if (! pod_type_p (type))
4907     {
4908       /* Remove reference types so we don't ICE later on.  */
4909       tree type1 = non_reference (type);
4910       /* Undefined behavior [expr.call] 5.2.2/7.  */
4911       warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4912                "call will abort at runtime", type);
4913       expr = convert (build_pointer_type (type1), null_node);
4914       expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4915                      call_builtin_trap (), expr);
4916       expr = cp_build_indirect_ref (expr, NULL, tf_warning_or_error);
4917       return expr;
4918     }
4919
4920   return build_va_arg (expr, type);
4921 }
4922
4923 /* TYPE has been given to va_arg.  Apply the default conversions which
4924    would have happened when passed via ellipsis.  Return the promoted
4925    type, or the passed type if there is no change.  */
4926
4927 tree
4928 cxx_type_promotes_to (tree type)
4929 {
4930   tree promote;
4931
4932   /* Perform the array-to-pointer and function-to-pointer
4933      conversions.  */
4934   type = type_decays_to (type);
4935
4936   promote = type_promotes_to (type);
4937   if (same_type_p (type, promote))
4938     promote = type;
4939
4940   return promote;
4941 }
4942
4943 /* ARG is a default argument expression being passed to a parameter of
4944    the indicated TYPE, which is a parameter to FN.  Do any required
4945    conversions.  Return the converted value.  */
4946
4947 static GTY(()) VEC(tree,gc) *default_arg_context;
4948
4949 tree
4950 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4951 {
4952   int i;
4953   tree t;
4954
4955   /* If the ARG is an unparsed default argument expression, the
4956      conversion cannot be performed.  */
4957   if (TREE_CODE (arg) == DEFAULT_ARG)
4958     {
4959       error ("the default argument for parameter %d of %qD has "
4960              "not yet been parsed",
4961              parmnum, fn);
4962       return error_mark_node;
4963     }
4964
4965   /* Detect recursion.  */
4966   for (i = 0; VEC_iterate (tree, default_arg_context, i, t); ++i)
4967     if (t == fn)
4968       {
4969         error ("recursive evaluation of default argument for %q#D", fn);
4970         return error_mark_node;
4971       }
4972   VEC_safe_push (tree, gc, default_arg_context, fn);
4973
4974   if (fn && DECL_TEMPLATE_INFO (fn))
4975     arg = tsubst_default_argument (fn, type, arg);
4976
4977   /* Due to:
4978
4979        [dcl.fct.default]
4980
4981        The names in the expression are bound, and the semantic
4982        constraints are checked, at the point where the default
4983        expressions appears.
4984
4985      we must not perform access checks here.  */
4986   push_deferring_access_checks (dk_no_check);
4987   arg = break_out_target_exprs (arg);
4988   if (TREE_CODE (arg) == CONSTRUCTOR)
4989     {
4990       arg = digest_init (type, arg);
4991       arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4992                                         "default argument", fn, parmnum,
4993                                         tf_warning_or_error);
4994     }
4995   else
4996     {
4997       /* We must make a copy of ARG, in case subsequent processing
4998          alters any part of it.  For example, during gimplification a
4999          cast of the form (T) &X::f (where "f" is a member function)
5000          will lead to replacing the PTRMEM_CST for &X::f with a
5001          VAR_DECL.  We can avoid the copy for constants, since they
5002          are never modified in place.  */
5003       if (!CONSTANT_CLASS_P (arg))
5004         arg = unshare_expr (arg);
5005       arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
5006                                         "default argument", fn, parmnum,
5007                                         tf_warning_or_error);
5008       arg = convert_for_arg_passing (type, arg);
5009     }
5010   pop_deferring_access_checks();
5011
5012   VEC_pop (tree, default_arg_context);
5013
5014   return arg;
5015 }
5016
5017 /* Returns the type which will really be used for passing an argument of
5018    type TYPE.  */
5019
5020 tree
5021 type_passed_as (tree type)
5022 {
5023   /* Pass classes with copy ctors by invisible reference.  */
5024   if (TREE_ADDRESSABLE (type))
5025     {
5026       type = build_reference_type (type);
5027       /* There are no other pointers to this temporary.  */
5028       type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
5029     }
5030   else if (targetm.calls.promote_prototypes (type)
5031            && INTEGRAL_TYPE_P (type)
5032            && COMPLETE_TYPE_P (type)
5033            && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5034                                    TYPE_SIZE (integer_type_node)))
5035     type = integer_type_node;
5036
5037   return type;
5038 }
5039
5040 /* Actually perform the appropriate conversion.  */
5041
5042 tree
5043 convert_for_arg_passing (tree type, tree val)
5044 {
5045   tree bitfield_type;
5046
5047   /* If VAL is a bitfield, then -- since it has already been converted
5048      to TYPE -- it cannot have a precision greater than TYPE.
5049
5050      If it has a smaller precision, we must widen it here.  For
5051      example, passing "int f:3;" to a function expecting an "int" will
5052      not result in any conversion before this point.
5053
5054      If the precision is the same we must not risk widening.  For
5055      example, the COMPONENT_REF for a 32-bit "long long" bitfield will
5056      often have type "int", even though the C++ type for the field is
5057      "long long".  If the value is being passed to a function
5058      expecting an "int", then no conversions will be required.  But,
5059      if we call convert_bitfield_to_declared_type, the bitfield will
5060      be converted to "long long".  */
5061   bitfield_type = is_bitfield_expr_with_lowered_type (val);
5062   if (bitfield_type
5063       && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
5064     val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
5065
5066   if (val == error_mark_node)
5067     ;
5068   /* Pass classes with copy ctors by invisible reference.  */
5069   else if (TREE_ADDRESSABLE (type))
5070     val = build1 (ADDR_EXPR, build_reference_type (type), val);
5071   else if (targetm.calls.promote_prototypes (type)
5072            && INTEGRAL_TYPE_P (type)
5073            && COMPLETE_TYPE_P (type)
5074            && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
5075                                    TYPE_SIZE (integer_type_node)))
5076     val = perform_integral_promotions (val);
5077   if (warn_missing_format_attribute)
5078     {
5079       tree rhstype = TREE_TYPE (val);
5080       const enum tree_code coder = TREE_CODE (rhstype);
5081       const enum tree_code codel = TREE_CODE (type);
5082       if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
5083           && coder == codel
5084           && check_missing_format_attribute (type, rhstype))
5085         warning (OPT_Wmissing_format_attribute,
5086                  "argument of function call might be a candidate for a format attribute");
5087     }
5088   return val;
5089 }
5090
5091 /* Returns true iff FN is a function with magic varargs, i.e. ones for
5092    which no conversions at all should be done.  This is true for some
5093    builtins which don't act like normal functions.  */
5094
5095 static bool
5096 magic_varargs_p (tree fn)
5097 {
5098   if (DECL_BUILT_IN (fn))
5099     switch (DECL_FUNCTION_CODE (fn))
5100       {
5101       case BUILT_IN_CLASSIFY_TYPE:
5102       case BUILT_IN_CONSTANT_P:
5103       case BUILT_IN_NEXT_ARG:
5104       case BUILT_IN_VA_START:
5105         return true;
5106
5107       default:;
5108         return lookup_attribute ("type generic",
5109                                  TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0;
5110       }
5111
5112   return false;
5113 }
5114
5115 /* Subroutine of the various build_*_call functions.  Overload resolution
5116    has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
5117    ARGS is a TREE_LIST of the unconverted arguments to the call.  FLAGS is a
5118    bitmask of various LOOKUP_* flags which apply to the call itself.  */
5119
5120 static tree
5121 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
5122 {
5123   tree fn = cand->fn;
5124   tree args = cand->args;
5125   conversion **convs = cand->convs;
5126   conversion *conv;
5127   tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
5128   int parmlen;
5129   tree arg, val;
5130   int i = 0;
5131   int j = 0;
5132   int is_method = 0;
5133   int nargs;
5134   tree *argarray;
5135   bool already_used = false;
5136
5137   /* In a template, there is no need to perform all of the work that
5138      is normally done.  We are only interested in the type of the call
5139      expression, i.e., the return type of the function.  Any semantic
5140      errors will be deferred until the template is instantiated.  */
5141   if (processing_template_decl)
5142     {
5143       tree expr;
5144       tree return_type;
5145       return_type = TREE_TYPE (TREE_TYPE (fn));
5146       expr = build_call_list (return_type, build_addr_func (fn), args);
5147       if (TREE_THIS_VOLATILE (fn) && cfun)
5148         current_function_returns_abnormally = 1;
5149       if (!VOID_TYPE_P (return_type))
5150         require_complete_type (return_type);
5151       return convert_from_reference (expr);
5152     }
5153
5154   /* Give any warnings we noticed during overload resolution.  */
5155   if (cand->warnings)
5156     {
5157       struct candidate_warning *w;
5158       for (w = cand->warnings; w; w = w->next)
5159         joust (cand, w->loser, 1);
5160     }
5161
5162   /* Make =delete work with SFINAE.  */
5163   if (DECL_DELETED_FN (fn) && !(complain & tf_error))
5164     return error_mark_node;
5165
5166   if (DECL_FUNCTION_MEMBER_P (fn))
5167     {
5168       /* If FN is a template function, two cases must be considered.
5169          For example:
5170
5171            struct A {
5172              protected:
5173                template <class T> void f();
5174            };
5175            template <class T> struct B {
5176              protected:
5177                void g();
5178            };
5179            struct C : A, B<int> {
5180              using A::f;        // #1
5181              using B<int>::g;   // #2
5182            };
5183
5184          In case #1 where `A::f' is a member template, DECL_ACCESS is
5185          recorded in the primary template but not in its specialization.
5186          We check access of FN using its primary template.
5187
5188          In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
5189          because it is a member of class template B, DECL_ACCESS is
5190          recorded in the specialization `B<int>::g'.  We cannot use its
5191          primary template because `B<T>::g' and `B<int>::g' may have
5192          different access.  */
5193       if (DECL_TEMPLATE_INFO (fn)
5194           && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
5195         perform_or_defer_access_check (cand->access_path,
5196                                        DECL_TI_TEMPLATE (fn), fn);
5197       else
5198         perform_or_defer_access_check (cand->access_path, fn, fn);
5199     }
5200
5201   if (args && TREE_CODE (args) != TREE_LIST)
5202     args = build_tree_list (NULL_TREE, args);
5203   arg = args;
5204
5205   /* Find maximum size of vector to hold converted arguments.  */
5206   parmlen = list_length (parm);
5207   nargs = list_length (args);
5208   if (parmlen > nargs)
5209     nargs = parmlen;
5210   argarray = (tree *) alloca (nargs * sizeof (tree));
5211
5212   /* The implicit parameters to a constructor are not considered by overload
5213      resolution, and must be of the proper type.  */
5214   if (DECL_CONSTRUCTOR_P (fn))
5215     {
5216       argarray[j++] = TREE_VALUE (arg);
5217       arg = TREE_CHAIN (arg);
5218       parm = TREE_CHAIN (parm);
5219       /* We should never try to call the abstract constructor.  */
5220       gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
5221
5222       if (DECL_HAS_VTT_PARM_P (fn))
5223         {
5224           argarray[j++] = TREE_VALUE (arg);
5225           arg = TREE_CHAIN (arg);
5226           parm = TREE_CHAIN (parm);
5227         }
5228     }
5229   /* Bypass access control for 'this' parameter.  */
5230   else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5231     {
5232       tree parmtype = TREE_VALUE (parm);
5233       tree argtype = TREE_TYPE (TREE_VALUE (arg));
5234       tree converted_arg;
5235       tree base_binfo;
5236
5237       if (convs[i]->bad_p)
5238         {
5239           if (complain & tf_error)
5240             permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers",
5241                        TREE_TYPE (argtype), fn);
5242           else
5243             return error_mark_node;
5244         }
5245
5246       /* [class.mfct.nonstatic]: If a nonstatic member function of a class
5247          X is called for an object that is not of type X, or of a type
5248          derived from X, the behavior is undefined.
5249
5250          So we can assume that anything passed as 'this' is non-null, and
5251          optimize accordingly.  */
5252       gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
5253       /* Convert to the base in which the function was declared.  */
5254       gcc_assert (cand->conversion_path != NULL_TREE);
5255       converted_arg = build_base_path (PLUS_EXPR,
5256                                        TREE_VALUE (arg),
5257                                        cand->conversion_path,
5258                                        1);
5259       /* Check that the base class is accessible.  */
5260       if (!accessible_base_p (TREE_TYPE (argtype),
5261                               BINFO_TYPE (cand->conversion_path), true))
5262         error ("%qT is not an accessible base of %qT",
5263                BINFO_TYPE (cand->conversion_path),
5264                TREE_TYPE (argtype));
5265       /* If fn was found by a using declaration, the conversion path
5266          will be to the derived class, not the base declaring fn. We
5267          must convert from derived to base.  */
5268       base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
5269                                 TREE_TYPE (parmtype), ba_unique, NULL);
5270       converted_arg = build_base_path (PLUS_EXPR, converted_arg,
5271                                        base_binfo, 1);
5272
5273       argarray[j++] = converted_arg;
5274       parm = TREE_CHAIN (parm);
5275       arg = TREE_CHAIN (arg);
5276       ++i;
5277       is_method = 1;
5278     }
5279
5280   for (; arg && parm;
5281        parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
5282     {
5283       tree type = TREE_VALUE (parm);
5284
5285       conv = convs[i];
5286
5287       /* Don't make a copy here if build_call is going to.  */
5288       if (conv->kind == ck_rvalue
5289           && COMPLETE_TYPE_P (complete_type (type))
5290           && !TREE_ADDRESSABLE (type))
5291         conv = conv->u.next;
5292
5293       val = convert_like_with_context
5294         (conv, TREE_VALUE (arg), fn, i - is_method, complain);
5295
5296       val = convert_for_arg_passing (type, val);
5297       if (val == error_mark_node)
5298         return error_mark_node;
5299       else
5300         argarray[j++] = val;
5301     }
5302
5303   /* Default arguments */
5304   for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
5305     argarray[j++] = convert_default_arg (TREE_VALUE (parm),
5306                                          TREE_PURPOSE (parm),
5307                                          fn, i - is_method);
5308   /* Ellipsis */
5309   for (; arg; arg = TREE_CHAIN (arg))
5310     {
5311       tree a = TREE_VALUE (arg);
5312       if (magic_varargs_p (fn))
5313         /* Do no conversions for magic varargs.  */;
5314       else
5315         a = convert_arg_to_ellipsis (a);
5316       argarray[j++] = a;
5317     }
5318
5319   gcc_assert (j <= nargs);
5320   nargs = j;
5321
5322   check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
5323                             nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
5324
5325   /* Avoid actually calling copy constructors and copy assignment operators,
5326      if possible.  */
5327
5328   if (! flag_elide_constructors)
5329     /* Do things the hard way.  */;
5330   else if (cand->num_convs == 1
5331            && (DECL_COPY_CONSTRUCTOR_P (fn)
5332                || DECL_MOVE_CONSTRUCTOR_P (fn)))
5333     {
5334       tree targ;
5335       arg = argarray[num_artificial_parms_for (fn)];
5336
5337       /* Pull out the real argument, disregarding const-correctness.  */
5338       targ = arg;
5339       while (CONVERT_EXPR_P (targ)
5340              || TREE_CODE (targ) == NON_LVALUE_EXPR)
5341         targ = TREE_OPERAND (targ, 0);
5342       if (TREE_CODE (targ) == ADDR_EXPR)
5343         {
5344           targ = TREE_OPERAND (targ, 0);
5345           if (!same_type_ignoring_top_level_qualifiers_p
5346               (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
5347             targ = NULL_TREE;
5348         }
5349       else
5350         targ = NULL_TREE;
5351
5352       if (targ)
5353         arg = targ;
5354       else
5355         arg = cp_build_indirect_ref (arg, 0, complain);
5356
5357       if (TREE_CODE (arg) == TARGET_EXPR
5358           && TARGET_EXPR_LIST_INIT_P (arg))
5359         {
5360           /* Copy-list-initialization doesn't require the copy constructor
5361              to be defined.  */
5362         }
5363       /* [class.copy]: the copy constructor is implicitly defined even if
5364          the implementation elided its use.  */
5365       else if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
5366         {
5367           mark_used (fn);
5368           already_used = true;
5369         }
5370
5371       /* If we're creating a temp and we already have one, don't create a
5372          new one.  If we're not creating a temp but we get one, use
5373          INIT_EXPR to collapse the temp into our target.  Otherwise, if the
5374          ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
5375          temp or an INIT_EXPR otherwise.  */
5376       if (integer_zerop (TREE_VALUE (args)))
5377         {
5378           if (TREE_CODE (arg) == TARGET_EXPR)
5379             return arg;
5380           else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
5381             return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
5382         }
5383       else if (TREE_CODE (arg) == TARGET_EXPR
5384                || (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn))
5385                    && !move_fn_p (fn)))
5386         {
5387           tree to = stabilize_reference
5388             (cp_build_indirect_ref (TREE_VALUE (args), 0, complain));
5389
5390           val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
5391           return val;
5392         }
5393     }
5394   else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
5395            && copy_fn_p (fn)
5396            && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
5397     {
5398       tree to = stabilize_reference
5399         (cp_build_indirect_ref (argarray[0], 0, complain));
5400       tree type = TREE_TYPE (to);
5401       tree as_base = CLASSTYPE_AS_BASE (type);
5402
5403       arg = argarray[1];
5404       if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5405         {
5406           arg = cp_build_indirect_ref (arg, 0, complain);
5407           val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5408         }
5409       else
5410         {
5411           /* We must only copy the non-tail padding parts.
5412              Use __builtin_memcpy for the bitwise copy.
5413              FIXME fix 22488 so we can go back to using MODIFY_EXPR
5414              instead of an explicit call to memcpy.  */
5415
5416           tree arg0, arg1, arg2, t;
5417           tree test = NULL_TREE;
5418
5419           arg2 = TYPE_SIZE_UNIT (as_base);
5420           arg1 = arg;
5421           arg0 = cp_build_unary_op (ADDR_EXPR, to, 0, complain);
5422
5423           if (!(optimize && flag_tree_ter))
5424             {
5425               /* When TER is off get_pointer_alignment returns 0, so a call
5426                  to __builtin_memcpy is expanded as a call to memcpy, which
5427                  is invalid with identical args.  When TER is on it is
5428                  expanded as a block move, which should be safe.  */
5429               arg0 = save_expr (arg0);
5430               arg1 = save_expr (arg1);
5431               test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
5432             }
5433           t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5434           t = build_call_n (t, 3, arg0, arg1, arg2);
5435
5436           t = convert (TREE_TYPE (arg0), t);
5437           if (test)
5438             t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
5439           val = cp_build_indirect_ref (t, 0, complain);
5440           TREE_NO_WARNING (val) = 1;
5441         }
5442
5443       return val;
5444     }
5445
5446   if (!already_used)
5447     mark_used (fn);
5448
5449   if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5450     {
5451       tree t;
5452       tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
5453                                 DECL_CONTEXT (fn),
5454                                 ba_any, NULL);
5455       gcc_assert (binfo && binfo != error_mark_node);
5456
5457       /* Warn about deprecated virtual functions now, since we're about
5458          to throw away the decl.  */
5459       if (TREE_DEPRECATED (fn))
5460         warn_deprecated_use (fn, NULL_TREE);
5461
5462       argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
5463       if (TREE_SIDE_EFFECTS (argarray[0]))
5464         argarray[0] = save_expr (argarray[0]);
5465       t = build_pointer_type (TREE_TYPE (fn));
5466       if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5467         fn = build_java_interface_fn_ref (fn, argarray[0]);
5468       else
5469         fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
5470       TREE_TYPE (fn) = t;
5471     }
5472   else
5473     fn = build_addr_func (fn);
5474
5475   return build_cxx_call (fn, nargs, argarray);
5476 }
5477
5478 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
5479    This function performs no overload resolution, conversion, or other
5480    high-level operations.  */
5481
5482 tree
5483 build_cxx_call (tree fn, int nargs, tree *argarray)
5484 {
5485   tree fndecl;
5486
5487   fn = build_call_a (fn, nargs, argarray);
5488
5489   /* If this call might throw an exception, note that fact.  */
5490   fndecl = get_callee_fndecl (fn);
5491   if ((!fndecl || !TREE_NOTHROW (fndecl))
5492       && at_function_scope_p ()
5493       && cfun)
5494     cp_function_chain->can_throw = 1;
5495
5496   /* Check that arguments to builtin functions match the expectations.  */
5497   if (fndecl
5498       && DECL_BUILT_IN (fndecl)
5499       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
5500       && !check_builtin_function_arguments (fndecl, nargs, argarray))
5501     return error_mark_node;
5502
5503   /* Some built-in function calls will be evaluated at compile-time in
5504      fold ().  */
5505   fn = fold_if_not_in_template (fn);
5506
5507   if (VOID_TYPE_P (TREE_TYPE (fn)))
5508     return fn;
5509
5510   fn = require_complete_type (fn);
5511   if (fn == error_mark_node)
5512     return error_mark_node;
5513
5514   if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
5515     fn = build_cplus_new (TREE_TYPE (fn), fn);
5516   return convert_from_reference (fn);
5517 }
5518
5519 static GTY(()) tree java_iface_lookup_fn;
5520
5521 /* Make an expression which yields the address of the Java interface
5522    method FN.  This is achieved by generating a call to libjava's
5523    _Jv_LookupInterfaceMethodIdx().  */
5524
5525 static tree
5526 build_java_interface_fn_ref (tree fn, tree instance)
5527 {
5528   tree lookup_fn, method, idx;
5529   tree klass_ref, iface, iface_ref;
5530   int i;
5531
5532   if (!java_iface_lookup_fn)
5533     {
5534       tree endlink = build_void_list_node ();
5535       tree t = tree_cons (NULL_TREE, ptr_type_node,
5536                           tree_cons (NULL_TREE, ptr_type_node,
5537                                      tree_cons (NULL_TREE, java_int_type_node,
5538                                                 endlink)));
5539       java_iface_lookup_fn
5540         = add_builtin_function ("_Jv_LookupInterfaceMethodIdx",
5541                                 build_function_type (ptr_type_node, t),
5542                                 0, NOT_BUILT_IN, NULL, NULL_TREE);
5543     }
5544
5545   /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5546      This is the first entry in the vtable.  */
5547   klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, 0,
5548                                                      tf_warning_or_error),
5549                               integer_zero_node);
5550
5551   /* Get the java.lang.Class pointer for the interface being called.  */
5552   iface = DECL_CONTEXT (fn);
5553   iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5554   if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5555       || DECL_CONTEXT (iface_ref) != iface)
5556     {
5557       error ("could not find class$ field in java interface type %qT",
5558                 iface);
5559       return error_mark_node;
5560     }
5561   iface_ref = build_address (iface_ref);
5562   iface_ref = convert (build_pointer_type (iface), iface_ref);
5563
5564   /* Determine the itable index of FN.  */
5565   i = 1;
5566   for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5567     {
5568       if (!DECL_VIRTUAL_P (method))
5569         continue;
5570       if (fn == method)
5571         break;
5572       i++;
5573     }
5574   idx = build_int_cst (NULL_TREE, i);
5575
5576   lookup_fn = build1 (ADDR_EXPR,
5577                       build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5578                       java_iface_lookup_fn);
5579   return build_call_nary (ptr_type_node, lookup_fn,
5580                           3, klass_ref, iface_ref, idx);
5581 }
5582
5583 /* Returns the value to use for the in-charge parameter when making a
5584    call to a function with the indicated NAME.
5585
5586    FIXME:Can't we find a neater way to do this mapping?  */
5587
5588 tree
5589 in_charge_arg_for_name (tree name)
5590 {
5591  if (name == base_ctor_identifier
5592       || name == base_dtor_identifier)
5593     return integer_zero_node;
5594   else if (name == complete_ctor_identifier)
5595     return integer_one_node;
5596   else if (name == complete_dtor_identifier)
5597     return integer_two_node;
5598   else if (name == deleting_dtor_identifier)
5599     return integer_three_node;
5600
5601   /* This function should only be called with one of the names listed
5602      above.  */
5603   gcc_unreachable ();
5604   return NULL_TREE;
5605 }
5606
5607 /* Build a call to a constructor, destructor, or an assignment
5608    operator for INSTANCE, an expression with class type.  NAME
5609    indicates the special member function to call; ARGS are the
5610    arguments.  BINFO indicates the base of INSTANCE that is to be
5611    passed as the `this' parameter to the member function called.
5612
5613    FLAGS are the LOOKUP_* flags to use when processing the call.
5614
5615    If NAME indicates a complete object constructor, INSTANCE may be
5616    NULL_TREE.  In this case, the caller will call build_cplus_new to
5617    store the newly constructed object into a VAR_DECL.  */
5618
5619 tree
5620 build_special_member_call (tree instance, tree name, tree args,
5621                            tree binfo, int flags, tsubst_flags_t complain)
5622 {
5623   tree fns;
5624   /* The type of the subobject to be constructed or destroyed.  */
5625   tree class_type;
5626
5627   gcc_assert (name == complete_ctor_identifier
5628               || name == base_ctor_identifier
5629               || name == complete_dtor_identifier
5630               || name == base_dtor_identifier
5631               || name == deleting_dtor_identifier
5632               || name == ansi_assopname (NOP_EXPR));
5633   if (TYPE_P (binfo))
5634     {
5635       /* Resolve the name.  */
5636       if (!complete_type_or_else (binfo, NULL_TREE))
5637         return error_mark_node;
5638
5639       binfo = TYPE_BINFO (binfo);
5640     }
5641
5642   gcc_assert (binfo != NULL_TREE);
5643
5644   class_type = BINFO_TYPE (binfo);
5645
5646   /* Handle the special case where INSTANCE is NULL_TREE.  */
5647   if (name == complete_ctor_identifier && !instance)
5648     {
5649       instance = build_int_cst (build_pointer_type (class_type), 0);
5650       instance = build1 (INDIRECT_REF, class_type, instance);
5651     }
5652   else
5653     {
5654       if (name == complete_dtor_identifier
5655           || name == base_dtor_identifier
5656           || name == deleting_dtor_identifier)
5657         gcc_assert (args == NULL_TREE);
5658
5659       /* Convert to the base class, if necessary.  */
5660       if (!same_type_ignoring_top_level_qualifiers_p
5661           (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5662         {
5663           if (name != ansi_assopname (NOP_EXPR))
5664             /* For constructors and destructors, either the base is
5665                non-virtual, or it is virtual but we are doing the
5666                conversion from a constructor or destructor for the
5667                complete object.  In either case, we can convert
5668                statically.  */
5669             instance = convert_to_base_statically (instance, binfo);
5670           else
5671             /* However, for assignment operators, we must convert
5672                dynamically if the base is virtual.  */
5673             instance = build_base_path (PLUS_EXPR, instance,
5674                                         binfo, /*nonnull=*/1);
5675         }
5676     }
5677
5678   gcc_assert (instance != NULL_TREE);
5679
5680   fns = lookup_fnfields (binfo, name, 1);
5681
5682   /* When making a call to a constructor or destructor for a subobject
5683      that uses virtual base classes, pass down a pointer to a VTT for
5684      the subobject.  */
5685   if ((name == base_ctor_identifier
5686        || name == base_dtor_identifier)
5687       && CLASSTYPE_VBASECLASSES (class_type))
5688     {
5689       tree vtt;
5690       tree sub_vtt;
5691
5692       /* If the current function is a complete object constructor
5693          or destructor, then we fetch the VTT directly.
5694          Otherwise, we look it up using the VTT we were given.  */
5695       vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5696       vtt = decay_conversion (vtt);
5697       vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5698                     build2 (EQ_EXPR, boolean_type_node,
5699                             current_in_charge_parm, integer_zero_node),
5700                     current_vtt_parm,
5701                     vtt);
5702       gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5703       sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
5704                         BINFO_SUBVTT_INDEX (binfo));
5705
5706       args = tree_cons (NULL_TREE, sub_vtt, args);
5707     }
5708
5709   return build_new_method_call (instance, fns, args,
5710                                 TYPE_BINFO (BINFO_TYPE (binfo)),
5711                                 flags, /*fn=*/NULL,
5712                                 complain);
5713 }
5714
5715 /* Return the NAME, as a C string.  The NAME indicates a function that
5716    is a member of TYPE.  *FREE_P is set to true if the caller must
5717    free the memory returned.
5718
5719    Rather than go through all of this, we should simply set the names
5720    of constructors and destructors appropriately, and dispense with
5721    ctor_identifier, dtor_identifier, etc.  */
5722
5723 static char *
5724 name_as_c_string (tree name, tree type, bool *free_p)
5725 {
5726   char *pretty_name;
5727
5728   /* Assume that we will not allocate memory.  */
5729   *free_p = false;
5730   /* Constructors and destructors are special.  */
5731   if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5732     {
5733       pretty_name
5734         = CONST_CAST (char *, IDENTIFIER_POINTER (constructor_name (type)));
5735       /* For a destructor, add the '~'.  */
5736       if (name == complete_dtor_identifier
5737           || name == base_dtor_identifier
5738           || name == deleting_dtor_identifier)
5739         {
5740           pretty_name = concat ("~", pretty_name, NULL);
5741           /* Remember that we need to free the memory allocated.  */
5742           *free_p = true;
5743         }
5744     }
5745   else if (IDENTIFIER_TYPENAME_P (name))
5746     {
5747       pretty_name = concat ("operator ",
5748                             type_as_string (TREE_TYPE (name),
5749                                             TFF_PLAIN_IDENTIFIER),
5750                             NULL);
5751       /* Remember that we need to free the memory allocated.  */
5752       *free_p = true;
5753     }
5754   else
5755     pretty_name = CONST_CAST (char *, IDENTIFIER_POINTER (name));
5756
5757   return pretty_name;
5758 }
5759
5760 /* Build a call to "INSTANCE.FN (ARGS)".  If FN_P is non-NULL, it will
5761    be set, upon return, to the function called.  */
5762
5763 tree
5764 build_new_method_call (tree instance, tree fns, tree args,
5765                        tree conversion_path, int flags,
5766                        tree *fn_p, tsubst_flags_t complain)
5767 {
5768   struct z_candidate *candidates = 0, *cand;
5769   tree explicit_targs = NULL_TREE;
5770   tree basetype = NULL_TREE;
5771   tree access_binfo;
5772   tree optype;
5773   tree mem_args = NULL_TREE, instance_ptr;
5774   tree name;
5775   tree user_args;
5776   tree call;
5777   tree fn;
5778   tree class_type;
5779   int template_only = 0;
5780   bool any_viable_p;
5781   tree orig_instance;
5782   tree orig_fns;
5783   tree orig_args;
5784   void *p;
5785
5786   gcc_assert (instance != NULL_TREE);
5787
5788   /* We don't know what function we're going to call, yet.  */
5789   if (fn_p)
5790     *fn_p = NULL_TREE;
5791
5792   if (error_operand_p (instance)
5793       || error_operand_p (fns)
5794       || args == error_mark_node)
5795     return error_mark_node;
5796
5797   if (!BASELINK_P (fns))
5798     {
5799       if (complain & tf_error)
5800         error ("call to non-function %qD", fns);
5801       return error_mark_node;
5802     }
5803
5804   orig_instance = instance;
5805   orig_fns = fns;
5806   orig_args = args;
5807
5808   /* Dismantle the baselink to collect all the information we need.  */
5809   if (!conversion_path)
5810     conversion_path = BASELINK_BINFO (fns);
5811   access_binfo = BASELINK_ACCESS_BINFO (fns);
5812   optype = BASELINK_OPTYPE (fns);
5813   fns = BASELINK_FUNCTIONS (fns);
5814   if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5815     {
5816       explicit_targs = TREE_OPERAND (fns, 1);
5817       fns = TREE_OPERAND (fns, 0);
5818       template_only = 1;
5819     }
5820   gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5821               || TREE_CODE (fns) == TEMPLATE_DECL
5822               || TREE_CODE (fns) == OVERLOAD);
5823   fn = get_first_fn (fns);
5824   name = DECL_NAME (fn);
5825
5826   basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5827   gcc_assert (CLASS_TYPE_P (basetype));
5828
5829   if (processing_template_decl)
5830     {
5831       instance = build_non_dependent_expr (instance);
5832       args = build_non_dependent_args (orig_args);
5833     }
5834
5835   /* The USER_ARGS are the arguments we will display to users if an
5836      error occurs.  The USER_ARGS should not include any
5837      compiler-generated arguments.  The "this" pointer hasn't been
5838      added yet.  However, we must remove the VTT pointer if this is a
5839      call to a base-class constructor or destructor.  */
5840   user_args = args;
5841   if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5842     {
5843       /* Callers should explicitly indicate whether they want to construct
5844          the complete object or just the part without virtual bases.  */
5845       gcc_assert (name != ctor_identifier);
5846       /* Similarly for destructors.  */
5847       gcc_assert (name != dtor_identifier);
5848       /* Remove the VTT pointer, if present.  */
5849       if ((name == base_ctor_identifier || name == base_dtor_identifier)
5850           && CLASSTYPE_VBASECLASSES (basetype))
5851         user_args = TREE_CHAIN (user_args);
5852     }
5853
5854   /* Process the argument list.  */
5855   args = resolve_args (args);
5856   if (args == error_mark_node)
5857     return error_mark_node;
5858
5859   instance_ptr = build_this (instance);
5860
5861   /* It's OK to call destructors and constructors on cv-qualified objects.
5862      Therefore, convert the INSTANCE_PTR to the unqualified type, if
5863      necessary.  */
5864   if (DECL_DESTRUCTOR_P (fn)
5865       || DECL_CONSTRUCTOR_P (fn))
5866     {
5867       tree type = build_pointer_type (basetype);
5868       if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5869         instance_ptr = build_nop (type, instance_ptr);
5870     }
5871   if (DECL_DESTRUCTOR_P (fn))
5872     name = complete_dtor_identifier;
5873
5874   /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
5875      initializer, not T({ }).  If the type doesn't have a list ctor,
5876      break apart the list into separate ctor args.  */
5877   if (DECL_CONSTRUCTOR_P (fn) && args
5878       && BRACE_ENCLOSED_INITIALIZER_P (TREE_VALUE (args))
5879       && CONSTRUCTOR_IS_DIRECT_INIT (TREE_VALUE (args))
5880       && !TYPE_HAS_LIST_CTOR (basetype))
5881     {
5882       gcc_assert (TREE_CHAIN (args) == NULL_TREE);
5883       args = ctor_to_list (TREE_VALUE (args));
5884     }
5885
5886   class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5887   mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5888
5889   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
5890   p = conversion_obstack_alloc (0);
5891
5892   for (fn = fns; fn; fn = OVL_NEXT (fn))
5893     {
5894       tree t = OVL_CURRENT (fn);
5895       tree this_arglist;
5896
5897       /* We can end up here for copy-init of same or base class.  */
5898       if ((flags & LOOKUP_ONLYCONVERTING)
5899           && DECL_NONCONVERTING_P (t))
5900         continue;
5901
5902       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5903         this_arglist = mem_args;
5904       else
5905         this_arglist = args;
5906
5907       if (TREE_CODE (t) == TEMPLATE_DECL)
5908         /* A member template.  */
5909         add_template_candidate (&candidates, t,
5910                                 class_type,
5911                                 explicit_targs,
5912                                 this_arglist, optype,
5913                                 access_binfo,
5914                                 conversion_path,
5915                                 flags,
5916                                 DEDUCE_CALL);
5917       else if (! template_only)
5918         add_function_candidate (&candidates, t,
5919                                 class_type,
5920                                 this_arglist,
5921                                 access_binfo,
5922                                 conversion_path,
5923                                 flags);
5924     }
5925
5926   candidates = splice_viable (candidates, pedantic, &any_viable_p);
5927   if (!any_viable_p)
5928     {
5929       if (complain & tf_error)
5930         {
5931           if (!COMPLETE_TYPE_P (basetype))
5932             cxx_incomplete_type_error (instance_ptr, basetype);
5933           else
5934             {
5935               char *pretty_name;
5936               bool free_p;
5937
5938               pretty_name = name_as_c_string (name, basetype, &free_p);
5939               error ("no matching function for call to %<%T::%s(%A)%#V%>",
5940                      basetype, pretty_name, user_args,
5941                      TREE_TYPE (TREE_TYPE (instance_ptr)));
5942               if (free_p)
5943                 free (pretty_name);
5944             }
5945           print_z_candidates (candidates);
5946         }
5947       call = error_mark_node;
5948     }
5949   else
5950     {
5951       cand = tourney (candidates);
5952       if (cand == 0)
5953         {
5954           char *pretty_name;
5955           bool free_p;
5956
5957           if (complain & tf_error)
5958             {
5959               pretty_name = name_as_c_string (name, basetype, &free_p);
5960               error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5961                      user_args);
5962               print_z_candidates (candidates);
5963               if (free_p)
5964                 free (pretty_name);
5965             }
5966           call = error_mark_node;
5967         }
5968       else
5969         {
5970           fn = cand->fn;
5971
5972           if (!(flags & LOOKUP_NONVIRTUAL)
5973               && DECL_PURE_VIRTUAL_P (fn)
5974               && instance == current_class_ref
5975               && (DECL_CONSTRUCTOR_P (current_function_decl)
5976                   || DECL_DESTRUCTOR_P (current_function_decl))
5977               && (complain & tf_warning))
5978             /* This is not an error, it is runtime undefined
5979                behavior.  */
5980             warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
5981                       "abstract virtual %q#D called from constructor"
5982                       : "abstract virtual %q#D called from destructor"),
5983                      fn);
5984
5985           if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
5986               && is_dummy_object (instance_ptr))
5987             {
5988               if (complain & tf_error)
5989                 error ("cannot call member function %qD without object",
5990                        fn);
5991               call = error_mark_node;
5992             }
5993           else
5994             {
5995               if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
5996                   && resolves_to_fixed_type_p (instance, 0))
5997                 flags |= LOOKUP_NONVIRTUAL;
5998               /* Now we know what function is being called.  */
5999               if (fn_p)
6000                 *fn_p = fn;
6001               /* Build the actual CALL_EXPR.  */
6002               call = build_over_call (cand, flags, complain);
6003               /* In an expression of the form `a->f()' where `f' turns
6004                  out to be a static member function, `a' is
6005                  none-the-less evaluated.  */
6006               if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
6007                   && !is_dummy_object (instance_ptr)
6008                   && TREE_SIDE_EFFECTS (instance_ptr))
6009                 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
6010                                instance_ptr, call);
6011               else if (call != error_mark_node
6012                        && DECL_DESTRUCTOR_P (cand->fn)
6013                        && !VOID_TYPE_P (TREE_TYPE (call)))
6014                 /* An explicit call of the form "x->~X()" has type
6015                    "void".  However, on platforms where destructors
6016                    return "this" (i.e., those where
6017                    targetm.cxx.cdtor_returns_this is true), such calls
6018                    will appear to have a return value of pointer type
6019                    to the low-level call machinery.  We do not want to
6020                    change the low-level machinery, since we want to be
6021                    able to optimize "delete f()" on such platforms as
6022                    "operator delete(~X(f()))" (rather than generating
6023                    "t = f(), ~X(t), operator delete (t)").  */
6024                 call = build_nop (void_type_node, call);
6025             }
6026         }
6027     }
6028
6029   if (processing_template_decl && call != error_mark_node)
6030     {
6031       bool cast_to_void = false;
6032
6033       if (TREE_CODE (call) == COMPOUND_EXPR)
6034         call = TREE_OPERAND (call, 1);
6035       else if (TREE_CODE (call) == NOP_EXPR)
6036         {
6037           cast_to_void = true;
6038           call = TREE_OPERAND (call, 0);
6039         }
6040       if (TREE_CODE (call) == INDIRECT_REF)
6041         call = TREE_OPERAND (call, 0);
6042       call = (build_min_non_dep_call_list
6043               (call,
6044                build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
6045                           orig_instance, orig_fns, NULL_TREE),
6046                orig_args));
6047       call = convert_from_reference (call);
6048       if (cast_to_void)
6049         call = build_nop (void_type_node, call);
6050     }
6051
6052  /* Free all the conversions we allocated.  */
6053   obstack_free (&conversion_obstack, p);
6054
6055   return call;
6056 }
6057
6058 /* Returns true iff standard conversion sequence ICS1 is a proper
6059    subsequence of ICS2.  */
6060
6061 static bool
6062 is_subseq (conversion *ics1, conversion *ics2)
6063 {
6064   /* We can assume that a conversion of the same code
6065      between the same types indicates a subsequence since we only get
6066      here if the types we are converting from are the same.  */
6067
6068   while (ics1->kind == ck_rvalue
6069          || ics1->kind == ck_lvalue)
6070     ics1 = ics1->u.next;
6071
6072   while (1)
6073     {
6074       while (ics2->kind == ck_rvalue
6075              || ics2->kind == ck_lvalue)
6076         ics2 = ics2->u.next;
6077
6078       if (ics2->kind == ck_user
6079           || ics2->kind == ck_ambig
6080           || ics2->kind == ck_identity)
6081         /* At this point, ICS1 cannot be a proper subsequence of
6082            ICS2.  We can get a USER_CONV when we are comparing the
6083            second standard conversion sequence of two user conversion
6084            sequences.  */
6085         return false;
6086
6087       ics2 = ics2->u.next;
6088
6089       if (ics2->kind == ics1->kind
6090           && same_type_p (ics2->type, ics1->type)
6091           && same_type_p (ics2->u.next->type,
6092                           ics1->u.next->type))
6093         return true;
6094     }
6095 }
6096
6097 /* Returns nonzero iff DERIVED is derived from BASE.  The inputs may
6098    be any _TYPE nodes.  */
6099
6100 bool
6101 is_properly_derived_from (tree derived, tree base)
6102 {
6103   if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
6104     return false;
6105
6106   /* We only allow proper derivation here.  The DERIVED_FROM_P macro
6107      considers every class derived from itself.  */
6108   return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
6109           && DERIVED_FROM_P (base, derived));
6110 }
6111
6112 /* We build the ICS for an implicit object parameter as a pointer
6113    conversion sequence.  However, such a sequence should be compared
6114    as if it were a reference conversion sequence.  If ICS is the
6115    implicit conversion sequence for an implicit object parameter,
6116    modify it accordingly.  */
6117
6118 static void
6119 maybe_handle_implicit_object (conversion **ics)
6120 {
6121   if ((*ics)->this_p)
6122     {
6123       /* [over.match.funcs]
6124
6125          For non-static member functions, the type of the
6126          implicit object parameter is "reference to cv X"
6127          where X is the class of which the function is a
6128          member and cv is the cv-qualification on the member
6129          function declaration.  */
6130       conversion *t = *ics;
6131       tree reference_type;
6132
6133       /* The `this' parameter is a pointer to a class type.  Make the
6134          implicit conversion talk about a reference to that same class
6135          type.  */
6136       reference_type = TREE_TYPE (t->type);
6137       reference_type = build_reference_type (reference_type);
6138
6139       if (t->kind == ck_qual)
6140         t = t->u.next;
6141       if (t->kind == ck_ptr)
6142         t = t->u.next;
6143       t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
6144       t = direct_reference_binding (reference_type, t);
6145       t->this_p = 1;
6146       t->rvaluedness_matches_p = 0;
6147       *ics = t;
6148     }
6149 }
6150
6151 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
6152    and return the initial reference binding conversion. Otherwise,
6153    leave *ICS unchanged and return NULL.  */
6154
6155 static conversion *
6156 maybe_handle_ref_bind (conversion **ics)
6157 {
6158   if ((*ics)->kind == ck_ref_bind)
6159     {
6160       conversion *old_ics = *ics;
6161       *ics = old_ics->u.next;
6162       (*ics)->user_conv_p = old_ics->user_conv_p;
6163       (*ics)->bad_p = old_ics->bad_p;
6164       return old_ics;
6165     }
6166
6167   return NULL;
6168 }
6169
6170 /* Compare two implicit conversion sequences according to the rules set out in
6171    [over.ics.rank].  Return values:
6172
6173       1: ics1 is better than ics2
6174      -1: ics2 is better than ics1
6175       0: ics1 and ics2 are indistinguishable */
6176
6177 static int
6178 compare_ics (conversion *ics1, conversion *ics2)
6179 {
6180   tree from_type1;
6181   tree from_type2;
6182   tree to_type1;
6183   tree to_type2;
6184   tree deref_from_type1 = NULL_TREE;
6185   tree deref_from_type2 = NULL_TREE;
6186   tree deref_to_type1 = NULL_TREE;
6187   tree deref_to_type2 = NULL_TREE;
6188   conversion_rank rank1, rank2;
6189
6190   /* REF_BINDING is nonzero if the result of the conversion sequence
6191      is a reference type.   In that case REF_CONV is the reference
6192      binding conversion. */
6193   conversion *ref_conv1;
6194   conversion *ref_conv2;
6195
6196   /* Handle implicit object parameters.  */
6197   maybe_handle_implicit_object (&ics1);
6198   maybe_handle_implicit_object (&ics2);
6199
6200   /* Handle reference parameters.  */
6201   ref_conv1 = maybe_handle_ref_bind (&ics1);
6202   ref_conv2 = maybe_handle_ref_bind (&ics2);
6203
6204   /* [over.ics.rank]
6205
6206      When  comparing  the  basic forms of implicit conversion sequences (as
6207      defined in _over.best.ics_)
6208
6209      --a standard conversion sequence (_over.ics.scs_) is a better
6210        conversion sequence than a user-defined conversion sequence
6211        or an ellipsis conversion sequence, and
6212
6213      --a user-defined conversion sequence (_over.ics.user_) is a
6214        better conversion sequence than an ellipsis conversion sequence
6215        (_over.ics.ellipsis_).  */
6216   rank1 = CONVERSION_RANK (ics1);
6217   rank2 = CONVERSION_RANK (ics2);
6218
6219   if (rank1 > rank2)
6220     return -1;
6221   else if (rank1 < rank2)
6222     return 1;
6223
6224   if (rank1 == cr_bad)
6225     {
6226       /* XXX Isn't this an extension? */
6227       /* Both ICS are bad.  We try to make a decision based on what
6228          would have happened if they'd been good.  */
6229       if (ics1->user_conv_p > ics2->user_conv_p
6230           || ics1->rank  > ics2->rank)
6231         return -1;
6232       else if (ics1->user_conv_p < ics2->user_conv_p
6233                || ics1->rank < ics2->rank)
6234         return 1;
6235
6236       /* We couldn't make up our minds; try to figure it out below.  */
6237     }
6238
6239   if (ics1->ellipsis_p)
6240     /* Both conversions are ellipsis conversions.  */
6241     return 0;
6242
6243   /* User-defined  conversion sequence U1 is a better conversion sequence
6244      than another user-defined conversion sequence U2 if they contain the
6245      same user-defined conversion operator or constructor and if the sec-
6246      ond standard conversion sequence of U1 is  better  than  the  second
6247      standard conversion sequence of U2.  */
6248
6249   if (ics1->user_conv_p)
6250     {
6251       conversion *t1;
6252       conversion *t2;
6253
6254       for (t1 = ics1; t1->kind != ck_user && t1->kind != ck_list; t1 = t1->u.next)
6255         if (t1->kind == ck_ambig || t1->kind == ck_aggr)
6256           return 0;
6257       for (t2 = ics2; t2->kind != ck_user && t2->kind != ck_list; t2 = t2->u.next)
6258         if (t2->kind == ck_ambig || t2->kind == ck_aggr)
6259           return 0;
6260
6261       /* Conversion to std::initializer_list is better than other
6262          user-defined conversions.  */
6263       if (t1->kind == ck_list
6264           || t2->kind == ck_list)
6265         {
6266           if (t2->kind != ck_list)
6267             return 1;
6268           else if (t1->kind != ck_list)
6269             return -1;
6270           else
6271             return 0;
6272         }
6273
6274       if (t1->cand->fn != t2->cand->fn)
6275         return 0;
6276
6277       /* We can just fall through here, after setting up
6278          FROM_TYPE1 and FROM_TYPE2.  */
6279       from_type1 = t1->type;
6280       from_type2 = t2->type;
6281     }
6282   else
6283     {
6284       conversion *t1;
6285       conversion *t2;
6286
6287       /* We're dealing with two standard conversion sequences.
6288
6289          [over.ics.rank]
6290
6291          Standard conversion sequence S1 is a better conversion
6292          sequence than standard conversion sequence S2 if
6293
6294          --S1 is a proper subsequence of S2 (comparing the conversion
6295            sequences in the canonical form defined by _over.ics.scs_,
6296            excluding any Lvalue Transformation; the identity
6297            conversion sequence is considered to be a subsequence of
6298            any non-identity conversion sequence */
6299
6300       t1 = ics1;
6301       while (t1->kind != ck_identity)
6302         t1 = t1->u.next;
6303       from_type1 = t1->type;
6304
6305       t2 = ics2;
6306       while (t2->kind != ck_identity)
6307         t2 = t2->u.next;
6308       from_type2 = t2->type;
6309     }
6310
6311   /* One sequence can only be a subsequence of the other if they start with
6312      the same type.  They can start with different types when comparing the
6313      second standard conversion sequence in two user-defined conversion
6314      sequences.  */
6315   if (same_type_p (from_type1, from_type2))
6316     {
6317       if (is_subseq (ics1, ics2))
6318         return 1;
6319       if (is_subseq (ics2, ics1))
6320         return -1;
6321     }
6322
6323   /* [over.ics.rank]
6324
6325      Or, if not that,
6326
6327      --the rank of S1 is better than the rank of S2 (by the rules
6328        defined below):
6329
6330     Standard conversion sequences are ordered by their ranks: an Exact
6331     Match is a better conversion than a Promotion, which is a better
6332     conversion than a Conversion.
6333
6334     Two conversion sequences with the same rank are indistinguishable
6335     unless one of the following rules applies:
6336
6337     --A conversion that is not a conversion of a pointer, or pointer
6338       to member, to bool is better than another conversion that is such
6339       a conversion.
6340
6341     The ICS_STD_RANK automatically handles the pointer-to-bool rule,
6342     so that we do not have to check it explicitly.  */
6343   if (ics1->rank < ics2->rank)
6344     return 1;
6345   else if (ics2->rank < ics1->rank)
6346     return -1;
6347
6348   to_type1 = ics1->type;
6349   to_type2 = ics2->type;
6350
6351   /* A conversion from scalar arithmetic type to complex is worse than a
6352      conversion between scalar arithmetic types.  */
6353   if (same_type_p (from_type1, from_type2)
6354       && ARITHMETIC_TYPE_P (from_type1)
6355       && ARITHMETIC_TYPE_P (to_type1)
6356       && ARITHMETIC_TYPE_P (to_type2)
6357       && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
6358           != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
6359     {
6360       if (TREE_CODE (to_type1) == COMPLEX_TYPE)
6361         return -1;
6362       else
6363         return 1;
6364     }
6365
6366   if (TYPE_PTR_P (from_type1)
6367       && TYPE_PTR_P (from_type2)
6368       && TYPE_PTR_P (to_type1)
6369       && TYPE_PTR_P (to_type2))
6370     {
6371       deref_from_type1 = TREE_TYPE (from_type1);
6372       deref_from_type2 = TREE_TYPE (from_type2);
6373       deref_to_type1 = TREE_TYPE (to_type1);
6374       deref_to_type2 = TREE_TYPE (to_type2);
6375     }
6376   /* The rules for pointers to members A::* are just like the rules
6377      for pointers A*, except opposite: if B is derived from A then
6378      A::* converts to B::*, not vice versa.  For that reason, we
6379      switch the from_ and to_ variables here.  */
6380   else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
6381             && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
6382            || (TYPE_PTRMEMFUNC_P (from_type1)
6383                && TYPE_PTRMEMFUNC_P (from_type2)
6384                && TYPE_PTRMEMFUNC_P (to_type1)
6385                && TYPE_PTRMEMFUNC_P (to_type2)))
6386     {
6387       deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
6388       deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
6389       deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
6390       deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
6391     }
6392
6393   if (deref_from_type1 != NULL_TREE
6394       && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
6395       && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
6396     {
6397       /* This was one of the pointer or pointer-like conversions.
6398
6399          [over.ics.rank]
6400
6401          --If class B is derived directly or indirectly from class A,
6402            conversion of B* to A* is better than conversion of B* to
6403            void*, and conversion of A* to void* is better than
6404            conversion of B* to void*.  */
6405       if (TREE_CODE (deref_to_type1) == VOID_TYPE
6406           && TREE_CODE (deref_to_type2) == VOID_TYPE)
6407         {
6408           if (is_properly_derived_from (deref_from_type1,
6409                                         deref_from_type2))
6410             return -1;
6411           else if (is_properly_derived_from (deref_from_type2,
6412                                              deref_from_type1))
6413             return 1;
6414         }
6415       else if (TREE_CODE (deref_to_type1) == VOID_TYPE
6416                || TREE_CODE (deref_to_type2) == VOID_TYPE)
6417         {
6418           if (same_type_p (deref_from_type1, deref_from_type2))
6419             {
6420               if (TREE_CODE (deref_to_type2) == VOID_TYPE)
6421                 {
6422                   if (is_properly_derived_from (deref_from_type1,
6423                                                 deref_to_type1))
6424                     return 1;
6425                 }
6426               /* We know that DEREF_TO_TYPE1 is `void' here.  */
6427               else if (is_properly_derived_from (deref_from_type1,
6428                                                  deref_to_type2))
6429                 return -1;
6430             }
6431         }
6432       else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
6433                && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
6434         {
6435           /* [over.ics.rank]
6436
6437              --If class B is derived directly or indirectly from class A
6438                and class C is derived directly or indirectly from B,
6439
6440              --conversion of C* to B* is better than conversion of C* to
6441                A*,
6442
6443              --conversion of B* to A* is better than conversion of C* to
6444                A*  */
6445           if (same_type_p (deref_from_type1, deref_from_type2))
6446             {
6447               if (is_properly_derived_from (deref_to_type1,
6448                                             deref_to_type2))
6449                 return 1;
6450               else if (is_properly_derived_from (deref_to_type2,
6451                                                  deref_to_type1))
6452                 return -1;
6453             }
6454           else if (same_type_p (deref_to_type1, deref_to_type2))
6455             {
6456               if (is_properly_derived_from (deref_from_type2,
6457                                             deref_from_type1))
6458                 return 1;
6459               else if (is_properly_derived_from (deref_from_type1,
6460                                                  deref_from_type2))
6461                 return -1;
6462             }
6463         }
6464     }
6465   else if (CLASS_TYPE_P (non_reference (from_type1))
6466            && same_type_p (from_type1, from_type2))
6467     {
6468       tree from = non_reference (from_type1);
6469
6470       /* [over.ics.rank]
6471
6472          --binding of an expression of type C to a reference of type
6473            B& is better than binding an expression of type C to a
6474            reference of type A&
6475
6476          --conversion of C to B is better than conversion of C to A,  */
6477       if (is_properly_derived_from (from, to_type1)
6478           && is_properly_derived_from (from, to_type2))
6479         {
6480           if (is_properly_derived_from (to_type1, to_type2))
6481             return 1;
6482           else if (is_properly_derived_from (to_type2, to_type1))
6483             return -1;
6484         }
6485     }
6486   else if (CLASS_TYPE_P (non_reference (to_type1))
6487            && same_type_p (to_type1, to_type2))
6488     {
6489       tree to = non_reference (to_type1);
6490
6491       /* [over.ics.rank]
6492
6493          --binding of an expression of type B to a reference of type
6494            A& is better than binding an expression of type C to a
6495            reference of type A&,
6496
6497          --conversion of B to A is better than conversion of C to A  */
6498       if (is_properly_derived_from (from_type1, to)
6499           && is_properly_derived_from (from_type2, to))
6500         {
6501           if (is_properly_derived_from (from_type2, from_type1))
6502             return 1;
6503           else if (is_properly_derived_from (from_type1, from_type2))
6504             return -1;
6505         }
6506     }
6507
6508   /* [over.ics.rank]
6509
6510      --S1 and S2 differ only in their qualification conversion and  yield
6511        similar  types  T1 and T2 (_conv.qual_), respectively, and the cv-
6512        qualification signature of type T1 is a proper subset of  the  cv-
6513        qualification signature of type T2  */
6514   if (ics1->kind == ck_qual
6515       && ics2->kind == ck_qual
6516       && same_type_p (from_type1, from_type2))
6517     {
6518       int result = comp_cv_qual_signature (to_type1, to_type2);
6519       if (result != 0)
6520         return result;
6521     }
6522
6523   /* [over.ics.rank]
6524
6525      --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
6526      to an implicit object parameter, and either S1 binds an lvalue reference
6527      to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
6528      reference to an rvalue and S2 binds an lvalue reference
6529      (C++0x draft standard, 13.3.3.2)
6530
6531      --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6532      types to which the references refer are the same type except for
6533      top-level cv-qualifiers, and the type to which the reference
6534      initialized by S2 refers is more cv-qualified than the type to
6535      which the reference initialized by S1 refers */
6536
6537   if (ref_conv1 && ref_conv2)
6538     {
6539       if (!ref_conv1->this_p && !ref_conv2->this_p
6540           && (TYPE_REF_IS_RVALUE (ref_conv1->type)
6541               != TYPE_REF_IS_RVALUE (ref_conv2->type)))
6542         {
6543           if (ref_conv1->rvaluedness_matches_p)
6544             return 1;
6545           if (ref_conv2->rvaluedness_matches_p)
6546             return -1;
6547         }
6548
6549       if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
6550         return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
6551                                       TREE_TYPE (ref_conv1->type));
6552     }
6553
6554   /* Neither conversion sequence is better than the other.  */
6555   return 0;
6556 }
6557
6558 /* The source type for this standard conversion sequence.  */
6559
6560 static tree
6561 source_type (conversion *t)
6562 {
6563   for (;; t = t->u.next)
6564     {
6565       if (t->kind == ck_user
6566           || t->kind == ck_ambig
6567           || t->kind == ck_identity)
6568         return t->type;
6569     }
6570   gcc_unreachable ();
6571 }
6572
6573 /* Note a warning about preferring WINNER to LOSER.  We do this by storing
6574    a pointer to LOSER and re-running joust to produce the warning if WINNER
6575    is actually used.  */
6576
6577 static void
6578 add_warning (struct z_candidate *winner, struct z_candidate *loser)
6579 {
6580   candidate_warning *cw = (candidate_warning *)
6581     conversion_obstack_alloc (sizeof (candidate_warning));
6582   cw->loser = loser;
6583   cw->next = winner->warnings;
6584   winner->warnings = cw;
6585 }
6586
6587 /* Compare two candidates for overloading as described in
6588    [over.match.best].  Return values:
6589
6590       1: cand1 is better than cand2
6591      -1: cand2 is better than cand1
6592       0: cand1 and cand2 are indistinguishable */
6593
6594 static int
6595 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
6596 {
6597   int winner = 0;
6598   int off1 = 0, off2 = 0;
6599   size_t i;
6600   size_t len;
6601
6602   /* Candidates that involve bad conversions are always worse than those
6603      that don't.  */
6604   if (cand1->viable > cand2->viable)
6605     return 1;
6606   if (cand1->viable < cand2->viable)
6607     return -1;
6608
6609   /* If we have two pseudo-candidates for conversions to the same type,
6610      or two candidates for the same function, arbitrarily pick one.  */
6611   if (cand1->fn == cand2->fn
6612       && (IS_TYPE_OR_DECL_P (cand1->fn)))
6613     return 1;
6614
6615   /* a viable function F1
6616      is defined to be a better function than another viable function F2  if
6617      for  all arguments i, ICSi(F1) is not a worse conversion sequence than
6618      ICSi(F2), and then */
6619
6620   /* for some argument j, ICSj(F1) is a better conversion  sequence  than
6621      ICSj(F2) */
6622
6623   /* For comparing static and non-static member functions, we ignore
6624      the implicit object parameter of the non-static function.  The
6625      standard says to pretend that the static function has an object
6626      parm, but that won't work with operator overloading.  */
6627   len = cand1->num_convs;
6628   if (len != cand2->num_convs)
6629     {
6630       int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
6631       int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
6632
6633       gcc_assert (static_1 != static_2);
6634
6635       if (static_1)
6636         off2 = 1;
6637       else
6638         {
6639           off1 = 1;
6640           --len;
6641         }
6642     }
6643
6644   for (i = 0; i < len; ++i)
6645     {
6646       conversion *t1 = cand1->convs[i + off1];
6647       conversion *t2 = cand2->convs[i + off2];
6648       int comp = compare_ics (t1, t2);
6649
6650       if (comp != 0)
6651         {
6652           if (warn_sign_promo
6653               && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
6654                   == cr_std + cr_promotion)
6655               && t1->kind == ck_std
6656               && t2->kind == ck_std
6657               && TREE_CODE (t1->type) == INTEGER_TYPE
6658               && TREE_CODE (t2->type) == INTEGER_TYPE
6659               && (TYPE_PRECISION (t1->type)
6660                   == TYPE_PRECISION (t2->type))
6661               && (TYPE_UNSIGNED (t1->u.next->type)
6662                   || (TREE_CODE (t1->u.next->type)
6663                       == ENUMERAL_TYPE)))
6664             {
6665               tree type = t1->u.next->type;
6666               tree type1, type2;
6667               struct z_candidate *w, *l;
6668               if (comp > 0)
6669                 type1 = t1->type, type2 = t2->type,
6670                   w = cand1, l = cand2;
6671               else
6672                 type1 = t2->type, type2 = t1->type,
6673                   w = cand2, l = cand1;
6674
6675               if (warn)
6676                 {
6677                   warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
6678                            type, type1, type2);
6679                   warning (OPT_Wsign_promo, "  in call to %qD", w->fn);
6680                 }
6681               else
6682                 add_warning (w, l);
6683             }
6684
6685           if (winner && comp != winner)
6686             {
6687               winner = 0;
6688               goto tweak;
6689             }
6690           winner = comp;
6691         }
6692     }
6693
6694   /* warn about confusing overload resolution for user-defined conversions,
6695      either between a constructor and a conversion op, or between two
6696      conversion ops.  */
6697   if (winner && warn_conversion && cand1->second_conv
6698       && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6699       && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6700     {
6701       struct z_candidate *w, *l;
6702       bool give_warning = false;
6703
6704       if (winner == 1)
6705         w = cand1, l = cand2;
6706       else
6707         w = cand2, l = cand1;
6708
6709       /* We don't want to complain about `X::operator T1 ()'
6710          beating `X::operator T2 () const', when T2 is a no less
6711          cv-qualified version of T1.  */
6712       if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6713           && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6714         {
6715           tree t = TREE_TYPE (TREE_TYPE (l->fn));
6716           tree f = TREE_TYPE (TREE_TYPE (w->fn));
6717
6718           if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6719             {
6720               t = TREE_TYPE (t);
6721               f = TREE_TYPE (f);
6722             }
6723           if (!comp_ptr_ttypes (t, f))
6724             give_warning = true;
6725         }
6726       else
6727         give_warning = true;
6728
6729       if (!give_warning)
6730         /*NOP*/;
6731       else if (warn)
6732         {
6733           tree source = source_type (w->convs[0]);
6734           if (! DECL_CONSTRUCTOR_P (w->fn))
6735             source = TREE_TYPE (source);
6736           if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
6737               && warning (OPT_Wconversion, "  for conversion from %qT to %qT",
6738                           source, w->second_conv->type))
6739             {
6740               inform (input_location, "  because conversion sequence for the argument is better");
6741             }
6742         }
6743       else
6744         add_warning (w, l);
6745     }
6746
6747   if (winner)
6748     return winner;
6749
6750   /* or, if not that,
6751      F1 is a non-template function and F2 is a template function
6752      specialization.  */
6753
6754   if (!cand1->template_decl && cand2->template_decl)
6755     return 1;
6756   else if (cand1->template_decl && !cand2->template_decl)
6757     return -1;
6758
6759   /* or, if not that,
6760      F1 and F2 are template functions and the function template for F1 is
6761      more specialized than the template for F2 according to the partial
6762      ordering rules.  */
6763
6764   if (cand1->template_decl && cand2->template_decl)
6765     {
6766       winner = more_specialized_fn
6767         (TI_TEMPLATE (cand1->template_decl),
6768          TI_TEMPLATE (cand2->template_decl),
6769          /* [temp.func.order]: The presence of unused ellipsis and default
6770             arguments has no effect on the partial ordering of function
6771             templates.   add_function_candidate() will not have
6772             counted the "this" argument for constructors.  */
6773          cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
6774       if (winner)
6775         return winner;
6776     }
6777
6778   /* or, if not that,
6779      the  context  is  an  initialization by user-defined conversion (see
6780      _dcl.init_  and  _over.match.user_)  and  the  standard   conversion
6781      sequence  from  the return type of F1 to the destination type (i.e.,
6782      the type of the entity being initialized)  is  a  better  conversion
6783      sequence  than the standard conversion sequence from the return type
6784      of F2 to the destination type.  */
6785
6786   if (cand1->second_conv)
6787     {
6788       winner = compare_ics (cand1->second_conv, cand2->second_conv);
6789       if (winner)
6790         return winner;
6791     }
6792
6793   /* Check whether we can discard a builtin candidate, either because we
6794      have two identical ones or matching builtin and non-builtin candidates.
6795
6796      (Pedantically in the latter case the builtin which matched the user
6797      function should not be added to the overload set, but we spot it here.
6798
6799      [over.match.oper]
6800      ... the builtin candidates include ...
6801      - do not have the same parameter type list as any non-template
6802        non-member candidate.  */
6803
6804   if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6805       || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6806     {
6807       for (i = 0; i < len; ++i)
6808         if (!same_type_p (cand1->convs[i]->type,
6809                           cand2->convs[i]->type))
6810           break;
6811       if (i == cand1->num_convs)
6812         {
6813           if (cand1->fn == cand2->fn)
6814             /* Two built-in candidates; arbitrarily pick one.  */
6815             return 1;
6816           else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6817             /* cand1 is built-in; prefer cand2.  */
6818             return -1;
6819           else
6820             /* cand2 is built-in; prefer cand1.  */
6821             return 1;
6822         }
6823     }
6824
6825   /* If the two function declarations represent the same function (this can
6826      happen with declarations in multiple scopes and arg-dependent lookup),
6827      arbitrarily choose one.  But first make sure the default args we're
6828      using match.  */
6829   if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6830       && equal_functions (cand1->fn, cand2->fn))
6831     {
6832       tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
6833       tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
6834
6835       gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
6836
6837       for (i = 0; i < len; ++i)
6838         {
6839           /* Don't crash if the fn is variadic.  */
6840           if (!parms1)
6841             break;
6842           parms1 = TREE_CHAIN (parms1);
6843           parms2 = TREE_CHAIN (parms2);
6844         }
6845
6846       if (off1)
6847         parms1 = TREE_CHAIN (parms1);
6848       else if (off2)
6849         parms2 = TREE_CHAIN (parms2);
6850
6851       for (; parms1; ++i)
6852         {
6853           if (!cp_tree_equal (TREE_PURPOSE (parms1),
6854                               TREE_PURPOSE (parms2)))
6855             {
6856               if (warn)
6857                 {
6858                   permerror (input_location, "default argument mismatch in "
6859                              "overload resolution");
6860                   inform (input_location,
6861                           " candidate 1: %q+#F", cand1->fn);
6862                   inform (input_location,
6863                           " candidate 2: %q+#F", cand2->fn);
6864                 }
6865               else
6866                 add_warning (cand1, cand2);
6867               break;
6868             }
6869           parms1 = TREE_CHAIN (parms1);
6870           parms2 = TREE_CHAIN (parms2);
6871         }
6872
6873       return 1;
6874     }
6875
6876 tweak:
6877
6878   /* Extension: If the worst conversion for one candidate is worse than the
6879      worst conversion for the other, take the first.  */
6880   if (!pedantic)
6881     {
6882       conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6883       struct z_candidate *w = 0, *l = 0;
6884
6885       for (i = 0; i < len; ++i)
6886         {
6887           if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6888             rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6889           if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6890             rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6891         }
6892       if (rank1 < rank2)
6893         winner = 1, w = cand1, l = cand2;
6894       if (rank1 > rank2)
6895         winner = -1, w = cand2, l = cand1;
6896       if (winner)
6897         {
6898           if (warn)
6899             {
6900               pedwarn (input_location, 0,
6901               "ISO C++ says that these are ambiguous, even "
6902               "though the worst conversion for the first is better than "
6903               "the worst conversion for the second:");
6904               print_z_candidate (_("candidate 1:"), w);
6905               print_z_candidate (_("candidate 2:"), l);
6906             }
6907           else
6908             add_warning (w, l);
6909           return winner;
6910         }
6911     }
6912
6913   gcc_assert (!winner);
6914   return 0;
6915 }
6916
6917 /* Given a list of candidates for overloading, find the best one, if any.
6918    This algorithm has a worst case of O(2n) (winner is last), and a best
6919    case of O(n/2) (totally ambiguous); much better than a sorting
6920    algorithm.  */
6921
6922 static struct z_candidate *
6923 tourney (struct z_candidate *candidates)
6924 {
6925   struct z_candidate *champ = candidates, *challenger;
6926   int fate;
6927   int champ_compared_to_predecessor = 0;
6928
6929   /* Walk through the list once, comparing each current champ to the next
6930      candidate, knocking out a candidate or two with each comparison.  */
6931
6932   for (challenger = champ->next; challenger; )
6933     {
6934       fate = joust (champ, challenger, 0);
6935       if (fate == 1)
6936         challenger = challenger->next;
6937       else
6938         {
6939           if (fate == 0)
6940             {
6941               champ = challenger->next;
6942               if (champ == 0)
6943                 return NULL;
6944               champ_compared_to_predecessor = 0;
6945             }
6946           else
6947             {
6948               champ = challenger;
6949               champ_compared_to_predecessor = 1;
6950             }
6951
6952           challenger = champ->next;
6953         }
6954     }
6955
6956   /* Make sure the champ is better than all the candidates it hasn't yet
6957      been compared to.  */
6958
6959   for (challenger = candidates;
6960        challenger != champ
6961          && !(champ_compared_to_predecessor && challenger->next == champ);
6962        challenger = challenger->next)
6963     {
6964       fate = joust (champ, challenger, 0);
6965       if (fate != 1)
6966         return NULL;
6967     }
6968
6969   return champ;
6970 }
6971
6972 /* Returns nonzero if things of type FROM can be converted to TO.  */
6973
6974 bool
6975 can_convert (tree to, tree from)
6976 {
6977   return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL);
6978 }
6979
6980 /* Returns nonzero if ARG (of type FROM) can be converted to TO.  */
6981
6982 bool
6983 can_convert_arg (tree to, tree from, tree arg, int flags)
6984 {
6985   conversion *t;
6986   void *p;
6987   bool ok_p;
6988
6989   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
6990   p = conversion_obstack_alloc (0);
6991
6992   t  = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6993                             flags);
6994   ok_p = (t && !t->bad_p);
6995
6996   /* Free all the conversions we allocated.  */
6997   obstack_free (&conversion_obstack, p);
6998
6999   return ok_p;
7000 }
7001
7002 /* Like can_convert_arg, but allows dubious conversions as well.  */
7003
7004 bool
7005 can_convert_arg_bad (tree to, tree from, tree arg)
7006 {
7007   conversion *t;
7008   void *p;
7009
7010   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7011   p = conversion_obstack_alloc (0);
7012   /* Try to perform the conversion.  */
7013   t  = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7014                             LOOKUP_NORMAL);
7015   /* Free all the conversions we allocated.  */
7016   obstack_free (&conversion_obstack, p);
7017
7018   return t != NULL;
7019 }
7020
7021 /* Convert EXPR to TYPE.  Return the converted expression.
7022
7023    Note that we allow bad conversions here because by the time we get to
7024    this point we are committed to doing the conversion.  If we end up
7025    doing a bad conversion, convert_like will complain.  */
7026
7027 tree
7028 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
7029 {
7030   conversion *conv;
7031   void *p;
7032
7033   if (error_operand_p (expr))
7034     return error_mark_node;
7035
7036   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7037   p = conversion_obstack_alloc (0);
7038
7039   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7040                               /*c_cast_p=*/false,
7041                               LOOKUP_NORMAL);
7042   if (!conv)
7043     {
7044       if (complain & tf_error)
7045         error ("could not convert %qE to %qT", expr, type);
7046       expr = error_mark_node;
7047     }
7048   else if (processing_template_decl)
7049     {
7050       /* In a template, we are only concerned about determining the
7051          type of non-dependent expressions, so we do not have to
7052          perform the actual conversion.  */
7053       if (TREE_TYPE (expr) != type)
7054         expr = build_nop (type, expr);
7055     }
7056   else
7057     expr = convert_like (conv, expr, complain);
7058
7059   /* Free all the conversions we allocated.  */
7060   obstack_free (&conversion_obstack, p);
7061
7062   return expr;
7063 }
7064
7065 /* Convert EXPR to TYPE (as a direct-initialization) if that is
7066    permitted.  If the conversion is valid, the converted expression is
7067    returned.  Otherwise, NULL_TREE is returned, except in the case
7068    that TYPE is a class type; in that case, an error is issued.  If
7069    C_CAST_P is true, then this direction initialization is taking
7070    place as part of a static_cast being attempted as part of a C-style
7071    cast.  */
7072
7073 tree
7074 perform_direct_initialization_if_possible (tree type,
7075                                            tree expr,
7076                                            bool c_cast_p,
7077                                            tsubst_flags_t complain)
7078 {
7079   conversion *conv;
7080   void *p;
7081
7082   if (type == error_mark_node || error_operand_p (expr))
7083     return error_mark_node;
7084   /* [dcl.init]
7085
7086      If the destination type is a (possibly cv-qualified) class type:
7087
7088      -- If the initialization is direct-initialization ...,
7089      constructors are considered. ... If no constructor applies, or
7090      the overload resolution is ambiguous, the initialization is
7091      ill-formed.  */
7092   if (CLASS_TYPE_P (type))
7093     {
7094       expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
7095                                         build_tree_list (NULL_TREE, expr),
7096                                         type, LOOKUP_NORMAL, complain);
7097       return build_cplus_new (type, expr);
7098     }
7099
7100   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7101   p = conversion_obstack_alloc (0);
7102
7103   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
7104                               c_cast_p,
7105                               LOOKUP_NORMAL);
7106   if (!conv || conv->bad_p)
7107     expr = NULL_TREE;
7108   else
7109     expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
7110                               /*issue_conversion_warnings=*/false,
7111                               c_cast_p,
7112                               tf_warning_or_error);
7113
7114   /* Free all the conversions we allocated.  */
7115   obstack_free (&conversion_obstack, p);
7116
7117   return expr;
7118 }
7119
7120 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE.  The reference
7121    is being bound to a temporary.  Create and return a new VAR_DECL
7122    with the indicated TYPE; this variable will store the value to
7123    which the reference is bound.  */
7124
7125 tree
7126 make_temporary_var_for_ref_to_temp (tree decl, tree type)
7127 {
7128   tree var;
7129
7130   /* Create the variable.  */
7131   var = create_temporary_var (type);
7132
7133   /* Register the variable.  */
7134   if (TREE_STATIC (decl))
7135     {
7136       /* Namespace-scope or local static; give it a mangled name.  */
7137       tree name;
7138
7139       TREE_STATIC (var) = 1;
7140       name = mangle_ref_init_variable (decl);
7141       DECL_NAME (var) = name;
7142       SET_DECL_ASSEMBLER_NAME (var, name);
7143       var = pushdecl_top_level (var);
7144     }
7145   else
7146     /* Create a new cleanup level if necessary.  */
7147     maybe_push_cleanup_level (type);
7148
7149   return var;
7150 }
7151
7152 /* EXPR is the initializer for a variable DECL of reference or
7153    std::initializer_list type.  Create, push and return a new VAR_DECL
7154    for the initializer so that it will live as long as DECL.  Any
7155    cleanup for the new variable is returned through CLEANUP, and the
7156    code to initialize the new variable is returned through INITP.  */
7157
7158 tree
7159 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
7160 {
7161   tree init;
7162   tree type;
7163   tree var;
7164
7165   /* Create the temporary variable.  */
7166   type = TREE_TYPE (expr);
7167   var = make_temporary_var_for_ref_to_temp (decl, type);
7168   layout_decl (var, 0);
7169   /* If the rvalue is the result of a function call it will be
7170      a TARGET_EXPR.  If it is some other construct (such as a
7171      member access expression where the underlying object is
7172      itself the result of a function call), turn it into a
7173      TARGET_EXPR here.  It is important that EXPR be a
7174      TARGET_EXPR below since otherwise the INIT_EXPR will
7175      attempt to make a bitwise copy of EXPR to initialize
7176      VAR.  */
7177   if (TREE_CODE (expr) != TARGET_EXPR)
7178     expr = get_target_expr (expr);
7179   /* Create the INIT_EXPR that will initialize the temporary
7180      variable.  */
7181   init = build2 (INIT_EXPR, type, var, expr);
7182   if (at_function_scope_p ())
7183     {
7184       add_decl_expr (var);
7185
7186       if (TREE_STATIC (var))
7187         init = add_stmt_to_compound (init, register_dtor_fn (var));
7188       else
7189         *cleanup = cxx_maybe_build_cleanup (var);
7190
7191       /* We must be careful to destroy the temporary only
7192          after its initialization has taken place.  If the
7193          initialization throws an exception, then the
7194          destructor should not be run.  We cannot simply
7195          transform INIT into something like:
7196
7197          (INIT, ({ CLEANUP_STMT; }))
7198
7199          because emit_local_var always treats the
7200          initializer as a full-expression.  Thus, the
7201          destructor would run too early; it would run at the
7202          end of initializing the reference variable, rather
7203          than at the end of the block enclosing the
7204          reference variable.
7205
7206          The solution is to pass back a cleanup expression
7207          which the caller is responsible for attaching to
7208          the statement tree.  */
7209     }
7210   else
7211     {
7212       rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
7213       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7214         static_aggregates = tree_cons (NULL_TREE, var,
7215                                        static_aggregates);
7216     }
7217
7218   *initp = init;
7219   return var;
7220 }
7221
7222 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
7223    initializing a variable of that TYPE.  If DECL is non-NULL, it is
7224    the VAR_DECL being initialized with the EXPR.  (In that case, the
7225    type of DECL will be TYPE.)  If DECL is non-NULL, then CLEANUP must
7226    also be non-NULL, and with *CLEANUP initialized to NULL.  Upon
7227    return, if *CLEANUP is no longer NULL, it will be an expression
7228    that should be pushed as a cleanup after the returned expression
7229    is used to initialize DECL.
7230
7231    Return the converted expression.  */
7232
7233 tree
7234 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
7235 {
7236   conversion *conv;
7237   void *p;
7238
7239   if (type == error_mark_node || error_operand_p (expr))
7240     return error_mark_node;
7241
7242   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7243   p = conversion_obstack_alloc (0);
7244
7245   conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
7246                             LOOKUP_NORMAL);
7247   if (!conv || conv->bad_p)
7248     {
7249       if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
7250           && !real_lvalue_p (expr))
7251         error ("invalid initialization of non-const reference of "
7252                "type %qT from a temporary of type %qT",
7253                type, TREE_TYPE (expr));
7254       else
7255         error ("invalid initialization of reference of type "
7256                "%qT from expression of type %qT", type,
7257                TREE_TYPE (expr));
7258       return error_mark_node;
7259     }
7260
7261   /* If DECL is non-NULL, then this special rule applies:
7262
7263        [class.temporary]
7264
7265        The temporary to which the reference is bound or the temporary
7266        that is the complete object to which the reference is bound
7267        persists for the lifetime of the reference.
7268
7269        The temporaries created during the evaluation of the expression
7270        initializing the reference, except the temporary to which the
7271        reference is bound, are destroyed at the end of the
7272        full-expression in which they are created.
7273
7274      In that case, we store the converted expression into a new
7275      VAR_DECL in a new scope.
7276
7277      However, we want to be careful not to create temporaries when
7278      they are not required.  For example, given:
7279
7280        struct B {};
7281        struct D : public B {};
7282        D f();
7283        const B& b = f();
7284
7285      there is no need to copy the return value from "f"; we can just
7286      extend its lifetime.  Similarly, given:
7287
7288        struct S {};
7289        struct T { operator S(); };
7290        T t;
7291        const S& s = t;
7292
7293     we can extend the lifetime of the return value of the conversion
7294     operator.  */
7295   gcc_assert (conv->kind == ck_ref_bind);
7296   if (decl)
7297     {
7298       tree var;
7299       tree base_conv_type;
7300
7301       /* Skip over the REF_BIND.  */
7302       conv = conv->u.next;
7303       /* If the next conversion is a BASE_CONV, skip that too -- but
7304          remember that the conversion was required.  */
7305       if (conv->kind == ck_base)
7306         {
7307           base_conv_type = conv->type;
7308           conv = conv->u.next;
7309         }
7310       else
7311         base_conv_type = NULL_TREE;
7312       /* Perform the remainder of the conversion.  */
7313       expr = convert_like_real (conv, expr,
7314                                 /*fn=*/NULL_TREE, /*argnum=*/0,
7315                                 /*inner=*/-1,
7316                                 /*issue_conversion_warnings=*/true,
7317                                 /*c_cast_p=*/false,
7318                                 tf_warning_or_error);
7319       if (error_operand_p (expr))
7320         expr = error_mark_node;
7321       else
7322         {
7323           if (!real_lvalue_p (expr))
7324             {
7325               tree init;
7326               var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
7327               /* Use its address to initialize the reference variable.  */
7328               expr = build_address (var);
7329               if (base_conv_type)
7330                 expr = convert_to_base (expr,
7331                                         build_pointer_type (base_conv_type),
7332                                         /*check_access=*/true,
7333                                         /*nonnull=*/true);
7334               expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
7335             }
7336           else
7337             /* Take the address of EXPR.  */
7338             expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
7339           /* If a BASE_CONV was required, perform it now.  */
7340           if (base_conv_type)
7341             expr = (perform_implicit_conversion
7342                     (build_pointer_type (base_conv_type), expr,
7343                      tf_warning_or_error));
7344           expr = build_nop (type, expr);
7345         }
7346     }
7347   else
7348     /* Perform the conversion.  */
7349     expr = convert_like (conv, expr, tf_warning_or_error);
7350
7351   /* Free all the conversions we allocated.  */
7352   obstack_free (&conversion_obstack, p);
7353
7354   return expr;
7355 }
7356
7357 /* Returns true iff TYPE is some variant of std::initializer_list.  */
7358
7359 bool
7360 is_std_init_list (tree type)
7361 {
7362   return (CLASS_TYPE_P (type)
7363           && CP_TYPE_CONTEXT (type) == std_node
7364           && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
7365 }
7366
7367 /* Returns true iff DECL is a list constructor: i.e. a constructor which
7368    will accept an argument list of a single std::initializer_list<T>.  */
7369
7370 bool
7371 is_list_ctor (tree decl)
7372 {
7373   tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
7374   tree arg;
7375
7376   if (!args || args == void_list_node)
7377     return false;
7378
7379   arg = non_reference (TREE_VALUE (args));
7380   if (!is_std_init_list (arg))
7381     return false;
7382
7383   args = TREE_CHAIN (args);
7384
7385   if (args && args != void_list_node && !TREE_PURPOSE (args))
7386     /* There are more non-defaulted parms.  */
7387     return false;
7388
7389   return true;
7390 }
7391
7392 #include "gt-cp-call.h"