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