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