gcc/cp/call.c

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