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