gcc/cp/call.c

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