gcc/cp/call.c

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