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