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