contrib/gcc-4.4/gcc/cp/call.c

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