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