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