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