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