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