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       /* Don't make a copy here if build_call is going to.  */
6172       if (conv->kind == ck_rvalue
6173           && COMPLETE_TYPE_P (complete_type (type))
6174           && !TREE_ADDRESSABLE (type))
6175         conv = conv->u.next;
6176
6177       /* Warn about initializer_list deduction that isn't currently in the
6178          working draft.  */
6179       if (cxx_dialect > cxx98
6180           && flag_deduce_init_list
6181           && cand->template_decl
6182           && is_std_init_list (non_reference (type))
6183           && BRACE_ENCLOSED_INITIALIZER_P (arg))
6184         {
6185           tree tmpl = TI_TEMPLATE (cand->template_decl);
6186           tree realparm = chain_index (j, DECL_ARGUMENTS (cand->fn));
6187           tree patparm = get_pattern_parm (realparm, tmpl);
6188           tree pattype = TREE_TYPE (patparm);
6189           if (PACK_EXPANSION_P (pattype))
6190             pattype = PACK_EXPANSION_PATTERN (pattype);
6191           pattype = non_reference (pattype);
6192
6193           if (TREE_CODE (pattype) == TEMPLATE_TYPE_PARM
6194               && (cand->explicit_targs == NULL_TREE
6195                   || (TREE_VEC_LENGTH (cand->explicit_targs)
6196                       <= TEMPLATE_TYPE_IDX (pattype))))
6197             {
6198               pedwarn (input_location, 0, "deducing %qT as %qT",
6199                        non_reference (TREE_TYPE (patparm)),
6200                        non_reference (type));
6201               pedwarn (input_location, 0, "  in call to %q+D", cand->fn);
6202               pedwarn (input_location, 0,
6203                        "  (you can disable this with -fno-deduce-init-list)");
6204             }
6205         }
6206
6207       val = convert_like_with_context (conv, arg, fn, i-is_method, complain);
6208
6209       val = convert_for_arg_passing (type, val);
6210       if (val == error_mark_node)
6211         return error_mark_node;
6212       else
6213         argarray[j++] = val;
6214     }
6215
6216   /* Default arguments */
6217   for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
6218     argarray[j++] = convert_default_arg (TREE_VALUE (parm),
6219                                          TREE_PURPOSE (parm),
6220                                          fn, i - is_method);
6221   /* Ellipsis */
6222   for (; arg_index < VEC_length (tree, args); ++arg_index)
6223     {
6224       tree a = VEC_index (tree, args, arg_index);
6225       if (magic_varargs_p (fn))
6226         /* Do no conversions for magic varargs.  */
6227         a = mark_type_use (a);
6228       else
6229         a = convert_arg_to_ellipsis (a);
6230       argarray[j++] = a;
6231     }
6232
6233   gcc_assert (j <= nargs);
6234   nargs = j;
6235
6236   check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
6237                             nargs, argarray, TYPE_ARG_TYPES (TREE_TYPE (fn)));
6238
6239   /* Avoid actually calling copy constructors and copy assignment operators,
6240      if possible.  */
6241
6242   if (! flag_elide_constructors)
6243     /* Do things the hard way.  */;
6244   else if (cand->num_convs == 1
6245            && (DECL_COPY_CONSTRUCTOR_P (fn)
6246                || DECL_MOVE_CONSTRUCTOR_P (fn)))
6247     {
6248       tree targ;
6249       tree arg = argarray[num_artificial_parms_for (fn)];
6250       tree fa;
6251       bool trivial = trivial_fn_p (fn);
6252
6253       /* Pull out the real argument, disregarding const-correctness.  */
6254       targ = arg;
6255       while (CONVERT_EXPR_P (targ)
6256              || TREE_CODE (targ) == NON_LVALUE_EXPR)
6257         targ = TREE_OPERAND (targ, 0);
6258       if (TREE_CODE (targ) == ADDR_EXPR)
6259         {
6260           targ = TREE_OPERAND (targ, 0);
6261           if (!same_type_ignoring_top_level_qualifiers_p
6262               (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
6263             targ = NULL_TREE;
6264         }
6265       else
6266         targ = NULL_TREE;
6267
6268       if (targ)
6269         arg = targ;
6270       else
6271         arg = cp_build_indirect_ref (arg, RO_NULL, complain);
6272
6273       /* [class.copy]: the copy constructor is implicitly defined even if
6274          the implementation elided its use.  */
6275       if (!trivial || DECL_DELETED_FN (fn))
6276         {
6277           mark_used (fn);
6278           already_used = true;
6279         }
6280
6281       /* If we're creating a temp and we already have one, don't create a
6282          new one.  If we're not creating a temp but we get one, use
6283          INIT_EXPR to collapse the temp into our target.  Otherwise, if the
6284          ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
6285          temp or an INIT_EXPR otherwise.  */
6286       fa = argarray[0];
6287       if (integer_zerop (fa))
6288         {
6289           if (TREE_CODE (arg) == TARGET_EXPR)
6290             return arg;
6291           else if (trivial)
6292             return force_target_expr (DECL_CONTEXT (fn), arg);
6293         }
6294       else if (TREE_CODE (arg) == TARGET_EXPR || trivial)
6295         {
6296           tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL,
6297                                                                 complain));
6298
6299           val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
6300           return val;
6301         }
6302     }
6303   else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
6304            && trivial_fn_p (fn)
6305            && !DECL_DELETED_FN (fn))
6306     {
6307       tree to = stabilize_reference
6308         (cp_build_indirect_ref (argarray[0], RO_NULL, complain));
6309       tree type = TREE_TYPE (to);
6310       tree as_base = CLASSTYPE_AS_BASE (type);
6311       tree arg = argarray[1];
6312
6313       if (is_really_empty_class (type))
6314         {
6315           /* Avoid copying empty classes.  */
6316           val = build2 (COMPOUND_EXPR, void_type_node, to, arg);
6317           TREE_NO_WARNING (val) = 1;
6318           val = build2 (COMPOUND_EXPR, type, val, to);
6319           TREE_NO_WARNING (val) = 1;
6320         }
6321       else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
6322         {
6323           arg = cp_build_indirect_ref (arg, RO_NULL, complain);
6324           val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
6325         }
6326       else
6327         {
6328           /* We must only copy the non-tail padding parts.
6329              Use __builtin_memcpy for the bitwise copy.
6330              FIXME fix 22488 so we can go back to using MODIFY_EXPR
6331              instead of an explicit call to memcpy.  */
6332
6333           tree arg0, arg1, arg2, t;
6334           tree test = NULL_TREE;
6335
6336           arg2 = TYPE_SIZE_UNIT (as_base);
6337           arg1 = arg;
6338           arg0 = cp_build_addr_expr (to, complain);
6339
6340           if (!can_trust_pointer_alignment ())
6341             {
6342               /* If we can't be sure about pointer alignment, a call
6343                  to __builtin_memcpy is expanded as a call to memcpy, which
6344                  is invalid with identical args.  Otherwise it is
6345                  expanded as a block move, which should be safe.  */
6346               arg0 = save_expr (arg0);
6347               arg1 = save_expr (arg1);
6348               test = build2 (EQ_EXPR, boolean_type_node, arg0, arg1);
6349             }
6350           t = implicit_built_in_decls[BUILT_IN_MEMCPY];
6351           t = build_call_n (t, 3, arg0, arg1, arg2);
6352
6353           t = convert (TREE_TYPE (arg0), t);
6354           if (test)
6355             t = build3 (COND_EXPR, TREE_TYPE (t), test, arg0, t);
6356           val = cp_build_indirect_ref (t, RO_NULL, complain);
6357           TREE_NO_WARNING (val) = 1;
6358         }
6359
6360       return val;
6361     }
6362   /* FIXME handle trivial default constructor and destructor, too.  */
6363
6364   if (!already_used)
6365     mark_used (fn);
6366
6367   if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
6368     {
6369       tree t;
6370       tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])),
6371                                 DECL_CONTEXT (fn),
6372                                 ba_any, NULL);
6373       gcc_assert (binfo && binfo != error_mark_node);
6374
6375       /* Warn about deprecated virtual functions now, since we're about
6376          to throw away the decl.  */
6377       if (TREE_DEPRECATED (fn))
6378         warn_deprecated_use (fn, NULL_TREE);
6379
6380       argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1);
6381       if (TREE_SIDE_EFFECTS (argarray[0]))
6382         argarray[0] = save_expr (argarray[0]);
6383       t = build_pointer_type (TREE_TYPE (fn));
6384       if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
6385         fn = build_java_interface_fn_ref (fn, argarray[0]);
6386       else
6387         fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn));
6388       TREE_TYPE (fn) = t;
6389     }
6390   else
6391     fn = build_addr_func (fn);
6392
6393   return build_cxx_call (fn, nargs, argarray);
6394 }
6395
6396 /* Build and return a call to FN, using NARGS arguments in ARGARRAY.
6397    This function performs no overload resolution, conversion, or other
6398    high-level operations.  */
6399
6400 tree
6401 build_cxx_call (tree fn, int nargs, tree *argarray)
6402 {
6403   tree fndecl;
6404
6405   fn = build_call_a (fn, nargs, argarray);
6406
6407   /* If this call might throw an exception, note that fact.  */
6408   fndecl = get_callee_fndecl (fn);
6409   if ((!fndecl || !TREE_NOTHROW (fndecl))
6410       && at_function_scope_p ()
6411       && cfun
6412       && cp_function_chain)
6413     cp_function_chain->can_throw = 1;
6414
6415   /* Check that arguments to builtin functions match the expectations.  */
6416   if (fndecl
6417       && DECL_BUILT_IN (fndecl)
6418       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6419       && !check_builtin_function_arguments (fndecl, nargs, argarray))
6420     return error_mark_node;
6421
6422   /* Some built-in function calls will be evaluated at compile-time in
6423      fold ().  */
6424   fn = fold_if_not_in_template (fn);
6425
6426   if (VOID_TYPE_P (TREE_TYPE (fn)))
6427     return fn;
6428
6429   fn = require_complete_type (fn);
6430   if (fn == error_mark_node)
6431     return error_mark_node;
6432
6433   if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn)))
6434     fn = build_cplus_new (TREE_TYPE (fn), fn);
6435   return convert_from_reference (fn);
6436 }
6437
6438 static GTY(()) tree java_iface_lookup_fn;
6439
6440 /* Make an expression which yields the address of the Java interface
6441    method FN.  This is achieved by generating a call to libjava's
6442    _Jv_LookupInterfaceMethodIdx().  */
6443
6444 static tree
6445 build_java_interface_fn_ref (tree fn, tree instance)
6446 {
6447   tree lookup_fn, method, idx;
6448   tree klass_ref, iface, iface_ref;
6449   int i;
6450
6451   if (!java_iface_lookup_fn)
6452     {
6453       tree ftype = build_function_type_list (ptr_type_node,
6454                                              ptr_type_node, ptr_type_node,
6455                                              java_int_type_node, NULL_TREE);
6456       java_iface_lookup_fn
6457         = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype,
6458                                 0, NOT_BUILT_IN, NULL, NULL_TREE);
6459     }
6460
6461   /* Look up the pointer to the runtime java.lang.Class object for `instance'.
6462      This is the first entry in the vtable.  */
6463   klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL,
6464                                                      tf_warning_or_error),
6465                               integer_zero_node);
6466
6467   /* Get the java.lang.Class pointer for the interface being called.  */
6468   iface = DECL_CONTEXT (fn);
6469   iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
6470   if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
6471       || DECL_CONTEXT (iface_ref) != iface)
6472     {
6473       error ("could not find class$ field in java interface type %qT",
6474                 iface);
6475       return error_mark_node;
6476     }
6477   iface_ref = build_address (iface_ref);
6478   iface_ref = convert (build_pointer_type (iface), iface_ref);
6479
6480   /* Determine the itable index of FN.  */
6481   i = 1;
6482   for (method = TYPE_METHODS (iface); method; method = DECL_CHAIN (method))
6483     {
6484       if (!DECL_VIRTUAL_P (method))
6485         continue;
6486       if (fn == method)
6487         break;
6488       i++;
6489     }
6490   idx = build_int_cst (NULL_TREE, i);
6491
6492   lookup_fn = build1 (ADDR_EXPR,
6493                       build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
6494                       java_iface_lookup_fn);
6495   return build_call_nary (ptr_type_node, lookup_fn,
6496                           3, klass_ref, iface_ref, idx);
6497 }
6498
6499 /* Returns the value to use for the in-charge parameter when making a
6500    call to a function with the indicated NAME.
6501
6502    FIXME:Can't we find a neater way to do this mapping?  */
6503
6504 tree
6505 in_charge_arg_for_name (tree name)
6506 {
6507  if (name == base_ctor_identifier
6508       || name == base_dtor_identifier)
6509     return integer_zero_node;
6510   else if (name == complete_ctor_identifier)
6511     return integer_one_node;
6512   else if (name == complete_dtor_identifier)
6513     return integer_two_node;
6514   else if (name == deleting_dtor_identifier)
6515     return integer_three_node;
6516
6517   /* This function should only be called with one of the names listed
6518      above.  */
6519   gcc_unreachable ();
6520   return NULL_TREE;
6521 }
6522
6523 /* Build a call to a constructor, destructor, or an assignment
6524    operator for INSTANCE, an expression with class type.  NAME
6525    indicates the special member function to call; *ARGS are the
6526    arguments.  ARGS may be NULL.  This may change ARGS.  BINFO
6527    indicates the base of INSTANCE that is to be passed as the `this'
6528    parameter to the member function called.
6529
6530    FLAGS are the LOOKUP_* flags to use when processing the call.
6531
6532    If NAME indicates a complete object constructor, INSTANCE may be
6533    NULL_TREE.  In this case, the caller will call build_cplus_new to
6534    store the newly constructed object into a VAR_DECL.  */
6535
6536 tree
6537 build_special_member_call (tree instance, tree name, VEC(tree,gc) **args,
6538                            tree binfo, int flags, tsubst_flags_t complain)
6539 {
6540   tree fns;
6541   /* The type of the subobject to be constructed or destroyed.  */
6542   tree class_type;
6543   VEC(tree,gc) *allocated = NULL;
6544   tree ret;
6545
6546   gcc_assert (name == complete_ctor_identifier
6547               || name == base_ctor_identifier
6548               || name == complete_dtor_identifier
6549               || name == base_dtor_identifier
6550               || name == deleting_dtor_identifier
6551               || name == ansi_assopname (NOP_EXPR));
6552   if (TYPE_P (binfo))
6553     {
6554       /* Resolve the name.  */
6555       if (!complete_type_or_maybe_complain (binfo, NULL_TREE, complain))
6556         return error_mark_node;
6557
6558       binfo = TYPE_BINFO (binfo);
6559     }
6560
6561   gcc_assert (binfo != NULL_TREE);
6562
6563   class_type = BINFO_TYPE (binfo);
6564
6565   /* Handle the special case where INSTANCE is NULL_TREE.  */
6566   if (name == complete_ctor_identifier && !instance)
6567     {
6568       instance = build_int_cst (build_pointer_type (class_type), 0);
6569       instance = build1 (INDIRECT_REF, class_type, instance);
6570     }
6571   else
6572     {
6573       if (name == complete_dtor_identifier
6574           || name == base_dtor_identifier
6575           || name == deleting_dtor_identifier)
6576         gcc_assert (args == NULL || VEC_empty (tree, *args));
6577
6578       /* Convert to the base class, if necessary.  */
6579       if (!same_type_ignoring_top_level_qualifiers_p
6580           (TREE_TYPE (instance), BINFO_TYPE (binfo)))
6581         {
6582           if (name != ansi_assopname (NOP_EXPR))
6583             /* For constructors and destructors, either the base is
6584                non-virtual, or it is virtual but we are doing the
6585                conversion from a constructor or destructor for the
6586                complete object.  In either case, we can convert
6587                statically.  */
6588             instance = convert_to_base_statically (instance, binfo);
6589           else
6590             /* However, for assignment operators, we must convert
6591                dynamically if the base is virtual.  */
6592             instance = build_base_path (PLUS_EXPR, instance,
6593                                         binfo, /*nonnull=*/1);
6594         }
6595     }
6596
6597   gcc_assert (instance != NULL_TREE);
6598
6599   fns = lookup_fnfields (binfo, name, 1);
6600
6601   /* When making a call to a constructor or destructor for a subobject
6602      that uses virtual base classes, pass down a pointer to a VTT for
6603      the subobject.  */
6604   if ((name == base_ctor_identifier
6605        || name == base_dtor_identifier)
6606       && CLASSTYPE_VBASECLASSES (class_type))
6607     {
6608       tree vtt;
6609       tree sub_vtt;
6610
6611       /* If the current function is a complete object constructor
6612          or destructor, then we fetch the VTT directly.
6613          Otherwise, we look it up using the VTT we were given.  */
6614       vtt = DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type));
6615       vtt = decay_conversion (vtt);
6616       vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
6617                     build2 (EQ_EXPR, boolean_type_node,
6618                             current_in_charge_parm, integer_zero_node),
6619                     current_vtt_parm,
6620                     vtt);
6621       gcc_assert (BINFO_SUBVTT_INDEX (binfo));
6622       sub_vtt = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtt), vtt,
6623                         BINFO_SUBVTT_INDEX (binfo));
6624
6625       if (args == NULL)
6626         {
6627           allocated = make_tree_vector ();
6628           args = &allocated;
6629         }
6630
6631       VEC_safe_insert (tree, gc, *args, 0, sub_vtt);
6632     }
6633
6634   ret = build_new_method_call (instance, fns, args,
6635                                TYPE_BINFO (BINFO_TYPE (binfo)),
6636                                flags, /*fn=*/NULL,
6637                                complain);
6638
6639   if (allocated != NULL)
6640     release_tree_vector (allocated);
6641
6642   return ret;
6643 }
6644
6645 /* Return the NAME, as a C string.  The NAME indicates a function that
6646    is a member of TYPE.  *FREE_P is set to true if the caller must
6647    free the memory returned.
6648
6649    Rather than go through all of this, we should simply set the names
6650    of constructors and destructors appropriately, and dispense with
6651    ctor_identifier, dtor_identifier, etc.  */
6652
6653 static char *
6654 name_as_c_string (tree name, tree type, bool *free_p)
6655 {
6656   char *pretty_name;
6657
6658   /* Assume that we will not allocate memory.  */
6659   *free_p = false;
6660   /* Constructors and destructors are special.  */
6661   if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6662     {
6663       pretty_name
6664         = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type))));
6665       /* For a destructor, add the '~'.  */
6666       if (name == complete_dtor_identifier
6667           || name == base_dtor_identifier
6668           || name == deleting_dtor_identifier)
6669         {
6670           pretty_name = concat ("~", pretty_name, NULL);
6671           /* Remember that we need to free the memory allocated.  */
6672           *free_p = true;
6673         }
6674     }
6675   else if (IDENTIFIER_TYPENAME_P (name))
6676     {
6677       pretty_name = concat ("operator ",
6678                             type_as_string_translate (TREE_TYPE (name),
6679                                                       TFF_PLAIN_IDENTIFIER),
6680                             NULL);
6681       /* Remember that we need to free the memory allocated.  */
6682       *free_p = true;
6683     }
6684   else
6685     pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name)));
6686
6687   return pretty_name;
6688 }
6689
6690 /* Build a call to "INSTANCE.FN (ARGS)".  If FN_P is non-NULL, it will
6691    be set, upon return, to the function called.  ARGS may be NULL.
6692    This may change ARGS.  */
6693
6694 tree
6695 build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args,
6696                        tree conversion_path, int flags,
6697                        tree *fn_p, tsubst_flags_t complain)
6698 {
6699   struct z_candidate *candidates = 0, *cand;
6700   tree explicit_targs = NULL_TREE;
6701   tree basetype = NULL_TREE;
6702   tree access_binfo;
6703   tree optype;
6704   tree first_mem_arg = NULL_TREE;
6705   tree instance_ptr;
6706   tree name;
6707   bool skip_first_for_error;
6708   VEC(tree,gc) *user_args;
6709   tree call;
6710   tree fn;
6711   int template_only = 0;
6712   bool any_viable_p;
6713   tree orig_instance;
6714   tree orig_fns;
6715   VEC(tree,gc) *orig_args = NULL;
6716   void *p;
6717
6718   gcc_assert (instance != NULL_TREE);
6719
6720   /* We don't know what function we're going to call, yet.  */
6721   if (fn_p)
6722     *fn_p = NULL_TREE;
6723
6724   if (error_operand_p (instance)
6725       || !fns || error_operand_p (fns))
6726     return error_mark_node;
6727
6728   if (!BASELINK_P (fns))
6729     {
6730       if (complain & tf_error)
6731         error ("call to non-function %qD", fns);
6732       return error_mark_node;
6733     }
6734
6735   orig_instance = instance;
6736   orig_fns = fns;
6737
6738   /* Dismantle the baselink to collect all the information we need.  */
6739   if (!conversion_path)
6740     conversion_path = BASELINK_BINFO (fns);
6741   access_binfo = BASELINK_ACCESS_BINFO (fns);
6742   optype = BASELINK_OPTYPE (fns);
6743   fns = BASELINK_FUNCTIONS (fns);
6744   if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
6745     {
6746       explicit_targs = TREE_OPERAND (fns, 1);
6747       fns = TREE_OPERAND (fns, 0);
6748       template_only = 1;
6749     }
6750   gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
6751               || TREE_CODE (fns) == TEMPLATE_DECL
6752               || TREE_CODE (fns) == OVERLOAD);
6753   fn = get_first_fn (fns);
6754   name = DECL_NAME (fn);
6755
6756   basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
6757   gcc_assert (CLASS_TYPE_P (basetype));
6758
6759   if (processing_template_decl)
6760     {
6761       orig_args = args == NULL ? NULL : make_tree_vector_copy (*args);
6762       instance = build_non_dependent_expr (instance);
6763       if (args != NULL)
6764         make_args_non_dependent (*args);
6765     }
6766
6767   user_args = args == NULL ? NULL : *args;
6768   /* Under DR 147 A::A() is an invalid constructor call,
6769      not a functional cast.  */
6770   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
6771     {
6772       if (! (complain & tf_error))
6773         return error_mark_node;
6774
6775       permerror (input_location,
6776                  "cannot call constructor %<%T::%D%> directly",
6777                  basetype, name);
6778       permerror (input_location, "  for a function-style cast, remove the "
6779                  "redundant %<::%D%>", name);
6780       call = build_functional_cast (basetype, build_tree_list_vec (user_args),
6781                                     complain);
6782       return call;
6783     }
6784
6785   /* Figure out whether to skip the first argument for the error
6786      message we will display to users if an error occurs.  We don't
6787      want to display any compiler-generated arguments.  The "this"
6788      pointer hasn't been added yet.  However, we must remove the VTT
6789      pointer if this is a call to a base-class constructor or
6790      destructor.  */
6791   skip_first_for_error = false;
6792   if (IDENTIFIER_CTOR_OR_DTOR_P (name))
6793     {
6794       /* Callers should explicitly indicate whether they want to construct
6795          the complete object or just the part without virtual bases.  */
6796       gcc_assert (name != ctor_identifier);
6797       /* Similarly for destructors.  */
6798       gcc_assert (name != dtor_identifier);
6799       /* Remove the VTT pointer, if present.  */
6800       if ((name == base_ctor_identifier || name == base_dtor_identifier)
6801           && CLASSTYPE_VBASECLASSES (basetype))
6802         skip_first_for_error = true;
6803     }
6804
6805   /* Process the argument list.  */
6806   if (args != NULL && *args != NULL)
6807     {
6808       *args = resolve_args (*args);
6809       if (*args == NULL)
6810         return error_mark_node;
6811     }
6812
6813   instance_ptr = build_this (instance);
6814
6815   /* It's OK to call destructors and constructors on cv-qualified objects.
6816      Therefore, convert the INSTANCE_PTR to the unqualified type, if
6817      necessary.  */
6818   if (DECL_DESTRUCTOR_P (fn)
6819       || DECL_CONSTRUCTOR_P (fn))
6820     {
6821       tree type = build_pointer_type (basetype);
6822       if (!same_type_p (type, TREE_TYPE (instance_ptr)))
6823         instance_ptr = build_nop (type, instance_ptr);
6824     }
6825   if (DECL_DESTRUCTOR_P (fn))
6826     name = complete_dtor_identifier;
6827
6828   first_mem_arg = instance_ptr;
6829
6830   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
6831   p = conversion_obstack_alloc (0);
6832
6833   /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form
6834      initializer, not T({ }).  */
6835   if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !VEC_empty (tree, *args)
6836       && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *args, 0))
6837       && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *args, 0)))
6838     {
6839       gcc_assert (VEC_length (tree, *args) == 1
6840                   && !(flags & LOOKUP_ONLYCONVERTING));
6841
6842       add_list_candidates (fns, first_mem_arg, VEC_index (tree, *args, 0),
6843                            basetype, explicit_targs, template_only,
6844                            conversion_path, access_binfo, flags, &candidates);
6845     }
6846   else
6847     {
6848       add_candidates (fns, first_mem_arg, user_args, optype,
6849                       explicit_targs, template_only, conversion_path,
6850                       access_binfo, flags, &candidates);
6851     }
6852   any_viable_p = false;
6853   candidates = splice_viable (candidates, pedantic, &any_viable_p);
6854
6855   if (!any_viable_p)
6856     {
6857       if (complain & tf_error)
6858         {
6859           if (!COMPLETE_OR_OPEN_TYPE_P (basetype))
6860             cxx_incomplete_type_error (instance_ptr, basetype);
6861           else if (optype)
6862             error ("no matching function for call to %<%T::operator %T(%A)%#V%>",
6863                    basetype, optype, build_tree_list_vec (user_args),
6864                    TREE_TYPE (TREE_TYPE (instance_ptr)));
6865           else
6866             {
6867               char *pretty_name;
6868               bool free_p;
6869               tree arglist;
6870
6871               pretty_name = name_as_c_string (name, basetype, &free_p);
6872               arglist = build_tree_list_vec (user_args);
6873               if (skip_first_for_error)
6874                 arglist = TREE_CHAIN (arglist);
6875               error ("no matching function for call to %<%T::%s(%A)%#V%>",
6876                      basetype, pretty_name, arglist,
6877                      TREE_TYPE (TREE_TYPE (instance_ptr)));
6878               if (free_p)
6879                 free (pretty_name);
6880             }
6881           print_z_candidates (location_of (name), candidates);
6882         }
6883       call = error_mark_node;
6884     }
6885   else
6886     {
6887       cand = tourney (candidates);
6888       if (cand == 0)
6889         {
6890           char *pretty_name;
6891           bool free_p;
6892           tree arglist;
6893
6894           if (complain & tf_error)
6895             {
6896               pretty_name = name_as_c_string (name, basetype, &free_p);
6897               arglist = build_tree_list_vec (user_args);
6898               if (skip_first_for_error)
6899                 arglist = TREE_CHAIN (arglist);
6900               error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
6901                      arglist);
6902               print_z_candidates (location_of (name), candidates);
6903               if (free_p)
6904                 free (pretty_name);
6905             }
6906           call = error_mark_node;
6907         }
6908       else
6909         {
6910           fn = cand->fn;
6911
6912           if (!(flags & LOOKUP_NONVIRTUAL)
6913               && DECL_PURE_VIRTUAL_P (fn)
6914               && instance == current_class_ref
6915               && (DECL_CONSTRUCTOR_P (current_function_decl)
6916                   || DECL_DESTRUCTOR_P (current_function_decl))
6917               && (complain & tf_warning))
6918             /* This is not an error, it is runtime undefined
6919                behavior.  */
6920             warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
6921                       "pure virtual %q#D called from constructor"
6922                       : "pure virtual %q#D called from destructor"),
6923                      fn);
6924
6925           if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
6926               && is_dummy_object (instance_ptr))
6927             {
6928               if (complain & tf_error)
6929                 error ("cannot call member function %qD without object",
6930                        fn);
6931               call = error_mark_node;
6932             }
6933           else
6934             {
6935               if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
6936                   && resolves_to_fixed_type_p (instance, 0))
6937                 flags |= LOOKUP_NONVIRTUAL;
6938               /* Now we know what function is being called.  */
6939               if (fn_p)
6940                 *fn_p = fn;
6941               /* Build the actual CALL_EXPR.  */
6942               call = build_over_call (cand, flags, complain);
6943               /* In an expression of the form `a->f()' where `f' turns
6944                  out to be a static member function, `a' is
6945                  none-the-less evaluated.  */
6946               if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
6947                   && !is_dummy_object (instance_ptr)
6948                   && TREE_SIDE_EFFECTS (instance_ptr))
6949                 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
6950                                instance_ptr, call);
6951               else if (call != error_mark_node
6952                        && DECL_DESTRUCTOR_P (cand->fn)
6953                        && !VOID_TYPE_P (TREE_TYPE (call)))
6954                 /* An explicit call of the form "x->~X()" has type
6955                    "void".  However, on platforms where destructors
6956                    return "this" (i.e., those where
6957                    targetm.cxx.cdtor_returns_this is true), such calls
6958                    will appear to have a return value of pointer type
6959                    to the low-level call machinery.  We do not want to
6960                    change the low-level machinery, since we want to be
6961                    able to optimize "delete f()" on such platforms as
6962                    "operator delete(~X(f()))" (rather than generating
6963                    "t = f(), ~X(t), operator delete (t)").  */
6964                 call = build_nop (void_type_node, call);
6965             }
6966         }
6967     }
6968
6969   if (processing_template_decl && call != error_mark_node)
6970     {
6971       bool cast_to_void = false;
6972
6973       if (TREE_CODE (call) == COMPOUND_EXPR)
6974         call = TREE_OPERAND (call, 1);
6975       else if (TREE_CODE (call) == NOP_EXPR)
6976         {
6977           cast_to_void = true;
6978           call = TREE_OPERAND (call, 0);
6979         }
6980       if (TREE_CODE (call) == INDIRECT_REF)
6981         call = TREE_OPERAND (call, 0);
6982       call = (build_min_non_dep_call_vec
6983               (call,
6984                build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)),
6985                           orig_instance, orig_fns, NULL_TREE),
6986                orig_args));
6987       call = convert_from_reference (call);
6988       if (cast_to_void)
6989         call = build_nop (void_type_node, call);
6990     }
6991
6992  /* Free all the conversions we allocated.  */
6993   obstack_free (&conversion_obstack, p);
6994
6995   if (orig_args != NULL)
6996     release_tree_vector (orig_args);
6997
6998   return call;
6999 }
7000
7001 /* Returns true iff standard conversion sequence ICS1 is a proper
7002    subsequence of ICS2.  */
7003
7004 static bool
7005 is_subseq (conversion *ics1, conversion *ics2)
7006 {
7007   /* We can assume that a conversion of the same code
7008      between the same types indicates a subsequence since we only get
7009      here if the types we are converting from are the same.  */
7010
7011   while (ics1->kind == ck_rvalue
7012          || ics1->kind == ck_lvalue)
7013     ics1 = ics1->u.next;
7014
7015   while (1)
7016     {
7017       while (ics2->kind == ck_rvalue
7018              || ics2->kind == ck_lvalue)
7019         ics2 = ics2->u.next;
7020
7021       if (ics2->kind == ck_user
7022           || ics2->kind == ck_ambig
7023           || ics2->kind == ck_aggr
7024           || ics2->kind == ck_list
7025           || ics2->kind == ck_identity)
7026         /* At this point, ICS1 cannot be a proper subsequence of
7027            ICS2.  We can get a USER_CONV when we are comparing the
7028            second standard conversion sequence of two user conversion
7029            sequences.  */
7030         return false;
7031
7032       ics2 = ics2->u.next;
7033
7034       if (ics2->kind == ics1->kind
7035           && same_type_p (ics2->type, ics1->type)
7036           && same_type_p (ics2->u.next->type,
7037                           ics1->u.next->type))
7038         return true;
7039     }
7040 }
7041
7042 /* Returns nonzero iff DERIVED is derived from BASE.  The inputs may
7043    be any _TYPE nodes.  */
7044
7045 bool
7046 is_properly_derived_from (tree derived, tree base)
7047 {
7048   if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base))
7049     return false;
7050
7051   /* We only allow proper derivation here.  The DERIVED_FROM_P macro
7052      considers every class derived from itself.  */
7053   return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
7054           && DERIVED_FROM_P (base, derived));
7055 }
7056
7057 /* We build the ICS for an implicit object parameter as a pointer
7058    conversion sequence.  However, such a sequence should be compared
7059    as if it were a reference conversion sequence.  If ICS is the
7060    implicit conversion sequence for an implicit object parameter,
7061    modify it accordingly.  */
7062
7063 static void
7064 maybe_handle_implicit_object (conversion **ics)
7065 {
7066   if ((*ics)->this_p)
7067     {
7068       /* [over.match.funcs]
7069
7070          For non-static member functions, the type of the
7071          implicit object parameter is "reference to cv X"
7072          where X is the class of which the function is a
7073          member and cv is the cv-qualification on the member
7074          function declaration.  */
7075       conversion *t = *ics;
7076       tree reference_type;
7077
7078       /* The `this' parameter is a pointer to a class type.  Make the
7079          implicit conversion talk about a reference to that same class
7080          type.  */
7081       reference_type = TREE_TYPE (t->type);
7082       reference_type = build_reference_type (reference_type);
7083
7084       if (t->kind == ck_qual)
7085         t = t->u.next;
7086       if (t->kind == ck_ptr)
7087         t = t->u.next;
7088       t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
7089       t = direct_reference_binding (reference_type, t);
7090       t->this_p = 1;
7091       t->rvaluedness_matches_p = 0;
7092       *ics = t;
7093     }
7094 }
7095
7096 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
7097    and return the initial reference binding conversion. Otherwise,
7098    leave *ICS unchanged and return NULL.  */
7099
7100 static conversion *
7101 maybe_handle_ref_bind (conversion **ics)
7102 {
7103   if ((*ics)->kind == ck_ref_bind)
7104     {
7105       conversion *old_ics = *ics;
7106       *ics = old_ics->u.next;
7107       (*ics)->user_conv_p = old_ics->user_conv_p;
7108       return old_ics;
7109     }
7110
7111   return NULL;
7112 }
7113
7114 /* Compare two implicit conversion sequences according to the rules set out in
7115    [over.ics.rank].  Return values:
7116
7117       1: ics1 is better than ics2
7118      -1: ics2 is better than ics1
7119       0: ics1 and ics2 are indistinguishable */
7120
7121 static int
7122 compare_ics (conversion *ics1, conversion *ics2)
7123 {
7124   tree from_type1;
7125   tree from_type2;
7126   tree to_type1;
7127   tree to_type2;
7128   tree deref_from_type1 = NULL_TREE;
7129   tree deref_from_type2 = NULL_TREE;
7130   tree deref_to_type1 = NULL_TREE;
7131   tree deref_to_type2 = NULL_TREE;
7132   conversion_rank rank1, rank2;
7133
7134   /* REF_BINDING is nonzero if the result of the conversion sequence
7135      is a reference type.   In that case REF_CONV is the reference
7136      binding conversion. */
7137   conversion *ref_conv1;
7138   conversion *ref_conv2;
7139
7140   /* Handle implicit object parameters.  */
7141   maybe_handle_implicit_object (&ics1);
7142   maybe_handle_implicit_object (&ics2);
7143
7144   /* Handle reference parameters.  */
7145   ref_conv1 = maybe_handle_ref_bind (&ics1);
7146   ref_conv2 = maybe_handle_ref_bind (&ics2);
7147
7148   /* List-initialization sequence L1 is a better conversion sequence than
7149      list-initialization sequence L2 if L1 converts to
7150      std::initializer_list<X> for some X and L2 does not.  */
7151   if (ics1->kind == ck_list && ics2->kind != ck_list)
7152     return 1;
7153   if (ics2->kind == ck_list && ics1->kind != ck_list)
7154     return -1;
7155
7156   /* [over.ics.rank]
7157
7158      When  comparing  the  basic forms of implicit conversion sequences (as
7159      defined in _over.best.ics_)
7160
7161      --a standard conversion sequence (_over.ics.scs_) is a better
7162        conversion sequence than a user-defined conversion sequence
7163        or an ellipsis conversion sequence, and
7164
7165      --a user-defined conversion sequence (_over.ics.user_) is a
7166        better conversion sequence than an ellipsis conversion sequence
7167        (_over.ics.ellipsis_).  */
7168   rank1 = CONVERSION_RANK (ics1);
7169   rank2 = CONVERSION_RANK (ics2);
7170
7171   if (rank1 > rank2)
7172     return -1;
7173   else if (rank1 < rank2)
7174     return 1;
7175
7176   if (rank1 == cr_bad)
7177     {
7178       /* Both ICS are bad.  We try to make a decision based on what would
7179          have happened if they'd been good.  This is not an extension,
7180          we'll still give an error when we build up the call; this just
7181          helps us give a more helpful error message.  */
7182       rank1 = BAD_CONVERSION_RANK (ics1);
7183       rank2 = BAD_CONVERSION_RANK (ics2);
7184
7185       if (rank1 > rank2)
7186         return -1;
7187       else if (rank1 < rank2)
7188         return 1;
7189
7190       /* We couldn't make up our minds; try to figure it out below.  */
7191     }
7192
7193   if (ics1->ellipsis_p)
7194     /* Both conversions are ellipsis conversions.  */
7195     return 0;
7196
7197   /* User-defined  conversion sequence U1 is a better conversion sequence
7198      than another user-defined conversion sequence U2 if they contain the
7199      same user-defined conversion operator or constructor and if the sec-
7200      ond standard conversion sequence of U1 is  better  than  the  second
7201      standard conversion sequence of U2.  */
7202
7203   /* Handle list-conversion with the same code even though it isn't always
7204      ranked as a user-defined conversion and it doesn't have a second
7205      standard conversion sequence; it will still have the desired effect.
7206      Specifically, we need to do the reference binding comparison at the
7207      end of this function.  */
7208
7209   if (ics1->user_conv_p || ics1->kind == ck_list)
7210     {
7211       conversion *t1;
7212       conversion *t2;
7213
7214       for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
7215         if (t1->kind == ck_ambig || t1->kind == ck_aggr
7216             || t1->kind == ck_list)
7217           break;
7218       for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
7219         if (t2->kind == ck_ambig || t2->kind == ck_aggr
7220             || t2->kind == ck_list)
7221           break;
7222
7223       if (t1->kind != t2->kind)
7224         return 0;
7225       else if (t1->kind == ck_user)
7226         {
7227           if (t1->cand->fn != t2->cand->fn)
7228             return 0;
7229         }
7230       else
7231         {
7232           /* For ambiguous or aggregate conversions, use the target type as
7233              a proxy for the conversion function.  */
7234           if (!same_type_ignoring_top_level_qualifiers_p (t1->type, t2->type))
7235             return 0;
7236         }
7237
7238       /* We can just fall through here, after setting up
7239          FROM_TYPE1 and FROM_TYPE2.  */
7240       from_type1 = t1->type;
7241       from_type2 = t2->type;
7242     }
7243   else
7244     {
7245       conversion *t1;
7246       conversion *t2;
7247
7248       /* We're dealing with two standard conversion sequences.
7249
7250          [over.ics.rank]
7251
7252          Standard conversion sequence S1 is a better conversion
7253          sequence than standard conversion sequence S2 if
7254
7255          --S1 is a proper subsequence of S2 (comparing the conversion
7256            sequences in the canonical form defined by _over.ics.scs_,
7257            excluding any Lvalue Transformation; the identity
7258            conversion sequence is considered to be a subsequence of
7259            any non-identity conversion sequence */
7260
7261       t1 = ics1;
7262       while (t1->kind != ck_identity)
7263         t1 = t1->u.next;
7264       from_type1 = t1->type;
7265
7266       t2 = ics2;
7267       while (t2->kind != ck_identity)
7268         t2 = t2->u.next;
7269       from_type2 = t2->type;
7270     }
7271
7272   /* One sequence can only be a subsequence of the other if they start with
7273      the same type.  They can start with different types when comparing the
7274      second standard conversion sequence in two user-defined conversion
7275      sequences.  */
7276   if (same_type_p (from_type1, from_type2))
7277     {
7278       if (is_subseq (ics1, ics2))
7279         return 1;
7280       if (is_subseq (ics2, ics1))
7281         return -1;
7282     }
7283
7284   /* [over.ics.rank]
7285
7286      Or, if not that,
7287
7288      --the rank of S1 is better than the rank of S2 (by the rules
7289        defined below):
7290
7291     Standard conversion sequences are ordered by their ranks: an Exact
7292     Match is a better conversion than a Promotion, which is a better
7293     conversion than a Conversion.
7294
7295     Two conversion sequences with the same rank are indistinguishable
7296     unless one of the following rules applies:
7297
7298     --A conversion that does not a convert a pointer, pointer to member,
7299       or std::nullptr_t to bool is better than one that does.
7300
7301     The ICS_STD_RANK automatically handles the pointer-to-bool rule,
7302     so that we do not have to check it explicitly.  */
7303   if (ics1->rank < ics2->rank)
7304     return 1;
7305   else if (ics2->rank < ics1->rank)
7306     return -1;
7307
7308   to_type1 = ics1->type;
7309   to_type2 = ics2->type;
7310
7311   /* A conversion from scalar arithmetic type to complex is worse than a
7312      conversion between scalar arithmetic types.  */
7313   if (same_type_p (from_type1, from_type2)
7314       && ARITHMETIC_TYPE_P (from_type1)
7315       && ARITHMETIC_TYPE_P (to_type1)
7316       && ARITHMETIC_TYPE_P (to_type2)
7317       && ((TREE_CODE (to_type1) == COMPLEX_TYPE)
7318           != (TREE_CODE (to_type2) == COMPLEX_TYPE)))
7319     {
7320       if (TREE_CODE (to_type1) == COMPLEX_TYPE)
7321         return -1;
7322       else
7323         return 1;
7324     }
7325
7326   if (TYPE_PTR_P (from_type1)
7327       && TYPE_PTR_P (from_type2)
7328       && TYPE_PTR_P (to_type1)
7329       && TYPE_PTR_P (to_type2))
7330     {
7331       deref_from_type1 = TREE_TYPE (from_type1);
7332       deref_from_type2 = TREE_TYPE (from_type2);
7333       deref_to_type1 = TREE_TYPE (to_type1);
7334       deref_to_type2 = TREE_TYPE (to_type2);
7335     }
7336   /* The rules for pointers to members A::* are just like the rules
7337      for pointers A*, except opposite: if B is derived from A then
7338      A::* converts to B::*, not vice versa.  For that reason, we
7339      switch the from_ and to_ variables here.  */
7340   else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
7341             && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
7342            || (TYPE_PTRMEMFUNC_P (from_type1)
7343                && TYPE_PTRMEMFUNC_P (from_type2)
7344                && TYPE_PTRMEMFUNC_P (to_type1)
7345                && TYPE_PTRMEMFUNC_P (to_type2)))
7346     {
7347       deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
7348       deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
7349       deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
7350       deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
7351     }
7352
7353   if (deref_from_type1 != NULL_TREE
7354       && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1))
7355       && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2)))
7356     {
7357       /* This was one of the pointer or pointer-like conversions.
7358
7359          [over.ics.rank]
7360
7361          --If class B is derived directly or indirectly from class A,
7362            conversion of B* to A* is better than conversion of B* to
7363            void*, and conversion of A* to void* is better than
7364            conversion of B* to void*.  */
7365       if (TREE_CODE (deref_to_type1) == VOID_TYPE
7366           && TREE_CODE (deref_to_type2) == VOID_TYPE)
7367         {
7368           if (is_properly_derived_from (deref_from_type1,
7369                                         deref_from_type2))
7370             return -1;
7371           else if (is_properly_derived_from (deref_from_type2,
7372                                              deref_from_type1))
7373             return 1;
7374         }
7375       else if (TREE_CODE (deref_to_type1) == VOID_TYPE
7376                || TREE_CODE (deref_to_type2) == VOID_TYPE)
7377         {
7378           if (same_type_p (deref_from_type1, deref_from_type2))
7379             {
7380               if (TREE_CODE (deref_to_type2) == VOID_TYPE)
7381                 {
7382                   if (is_properly_derived_from (deref_from_type1,
7383                                                 deref_to_type1))
7384                     return 1;
7385                 }
7386               /* We know that DEREF_TO_TYPE1 is `void' here.  */
7387               else if (is_properly_derived_from (deref_from_type1,
7388                                                  deref_to_type2))
7389                 return -1;
7390             }
7391         }
7392       else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1))
7393                && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2)))
7394         {
7395           /* [over.ics.rank]
7396
7397              --If class B is derived directly or indirectly from class A
7398                and class C is derived directly or indirectly from B,
7399
7400              --conversion of C* to B* is better than conversion of C* to
7401                A*,
7402
7403              --conversion of B* to A* is better than conversion of C* to
7404                A*  */
7405           if (same_type_p (deref_from_type1, deref_from_type2))
7406             {
7407               if (is_properly_derived_from (deref_to_type1,
7408                                             deref_to_type2))
7409                 return 1;
7410               else if (is_properly_derived_from (deref_to_type2,
7411                                                  deref_to_type1))
7412                 return -1;
7413             }
7414           else if (same_type_p (deref_to_type1, deref_to_type2))
7415             {
7416               if (is_properly_derived_from (deref_from_type2,
7417                                             deref_from_type1))
7418                 return 1;
7419               else if (is_properly_derived_from (deref_from_type1,
7420                                                  deref_from_type2))
7421                 return -1;
7422             }
7423         }
7424     }
7425   else if (CLASS_TYPE_P (non_reference (from_type1))
7426            && same_type_p (from_type1, from_type2))
7427     {
7428       tree from = non_reference (from_type1);
7429
7430       /* [over.ics.rank]
7431
7432          --binding of an expression of type C to a reference of type
7433            B& is better than binding an expression of type C to a
7434            reference of type A&
7435
7436          --conversion of C to B is better than conversion of C to A,  */
7437       if (is_properly_derived_from (from, to_type1)
7438           && is_properly_derived_from (from, to_type2))
7439         {
7440           if (is_properly_derived_from (to_type1, to_type2))
7441             return 1;
7442           else if (is_properly_derived_from (to_type2, to_type1))
7443             return -1;
7444         }
7445     }
7446   else if (CLASS_TYPE_P (non_reference (to_type1))
7447            && same_type_p (to_type1, to_type2))
7448     {
7449       tree to = non_reference (to_type1);
7450
7451       /* [over.ics.rank]
7452
7453          --binding of an expression of type B to a reference of type
7454            A& is better than binding an expression of type C to a
7455            reference of type A&,
7456
7457          --conversion of B to A is better than conversion of C to A  */
7458       if (is_properly_derived_from (from_type1, to)
7459           && is_properly_derived_from (from_type2, to))
7460         {
7461           if (is_properly_derived_from (from_type2, from_type1))
7462             return 1;
7463           else if (is_properly_derived_from (from_type1, from_type2))
7464             return -1;
7465         }
7466     }
7467
7468   /* [over.ics.rank]
7469
7470      --S1 and S2 differ only in their qualification conversion and  yield
7471        similar  types  T1 and T2 (_conv.qual_), respectively, and the cv-
7472        qualification signature of type T1 is a proper subset of  the  cv-
7473        qualification signature of type T2  */
7474   if (ics1->kind == ck_qual
7475       && ics2->kind == ck_qual
7476       && same_type_p (from_type1, from_type2))
7477     {
7478       int result = comp_cv_qual_signature (to_type1, to_type2);
7479       if (result != 0)
7480         return result;
7481     }
7482
7483   /* [over.ics.rank]
7484
7485      --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers
7486      to an implicit object parameter, and either S1 binds an lvalue reference
7487      to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue
7488      reference to an rvalue and S2 binds an lvalue reference
7489      (C++0x draft standard, 13.3.3.2)
7490
7491      --S1 and S2 are reference bindings (_dcl.init.ref_), and the
7492      types to which the references refer are the same type except for
7493      top-level cv-qualifiers, and the type to which the reference
7494      initialized by S2 refers is more cv-qualified than the type to
7495      which the reference initialized by S1 refers */
7496
7497   if (ref_conv1 && ref_conv2)
7498     {
7499       if (!ref_conv1->this_p && !ref_conv2->this_p
7500           && (TYPE_REF_IS_RVALUE (ref_conv1->type)
7501               != TYPE_REF_IS_RVALUE (ref_conv2->type)))
7502         {
7503           if (ref_conv1->rvaluedness_matches_p)
7504             return 1;
7505           if (ref_conv2->rvaluedness_matches_p)
7506             return -1;
7507         }
7508
7509       if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
7510         return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
7511                                       TREE_TYPE (ref_conv1->type));
7512     }
7513
7514   /* Neither conversion sequence is better than the other.  */
7515   return 0;
7516 }
7517
7518 /* The source type for this standard conversion sequence.  */
7519
7520 static tree
7521 source_type (conversion *t)
7522 {
7523   for (;; t = t->u.next)
7524     {
7525       if (t->kind == ck_user
7526           || t->kind == ck_ambig
7527           || t->kind == ck_identity)
7528         return t->type;
7529     }
7530   gcc_unreachable ();
7531 }
7532
7533 /* Note a warning about preferring WINNER to LOSER.  We do this by storing
7534    a pointer to LOSER and re-running joust to produce the warning if WINNER
7535    is actually used.  */
7536
7537 static void
7538 add_warning (struct z_candidate *winner, struct z_candidate *loser)
7539 {
7540   candidate_warning *cw = (candidate_warning *)
7541     conversion_obstack_alloc (sizeof (candidate_warning));
7542   cw->loser = loser;
7543   cw->next = winner->warnings;
7544   winner->warnings = cw;
7545 }
7546
7547 /* Compare two candidates for overloading as described in
7548    [over.match.best].  Return values:
7549
7550       1: cand1 is better than cand2
7551      -1: cand2 is better than cand1
7552       0: cand1 and cand2 are indistinguishable */
7553
7554 static int
7555 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
7556 {
7557   int winner = 0;
7558   int off1 = 0, off2 = 0;
7559   size_t i;
7560   size_t len;
7561
7562   /* Candidates that involve bad conversions are always worse than those
7563      that don't.  */
7564   if (cand1->viable > cand2->viable)
7565     return 1;
7566   if (cand1->viable < cand2->viable)
7567     return -1;
7568
7569   /* If we have two pseudo-candidates for conversions to the same type,
7570      or two candidates for the same function, arbitrarily pick one.  */
7571   if (cand1->fn == cand2->fn
7572       && (IS_TYPE_OR_DECL_P (cand1->fn)))
7573     return 1;
7574
7575   /* a viable function F1
7576      is defined to be a better function than another viable function F2  if
7577      for  all arguments i, ICSi(F1) is not a worse conversion sequence than
7578      ICSi(F2), and then */
7579
7580   /* for some argument j, ICSj(F1) is a better conversion  sequence  than
7581      ICSj(F2) */
7582
7583   /* For comparing static and non-static member functions, we ignore
7584      the implicit object parameter of the non-static function.  The
7585      standard says to pretend that the static function has an object
7586      parm, but that won't work with operator overloading.  */
7587   len = cand1->num_convs;
7588   if (len != cand2->num_convs)
7589     {
7590       int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
7591       int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
7592
7593       gcc_assert (static_1 != static_2);
7594
7595       if (static_1)
7596         off2 = 1;
7597       else
7598         {
7599           off1 = 1;
7600           --len;
7601         }
7602     }
7603
7604   for (i = 0; i < len; ++i)
7605     {
7606       conversion *t1 = cand1->convs[i + off1];
7607       conversion *t2 = cand2->convs[i + off2];
7608       int comp = compare_ics (t1, t2);
7609
7610       if (comp != 0)
7611         {
7612           if (warn_sign_promo
7613               && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
7614                   == cr_std + cr_promotion)
7615               && t1->kind == ck_std
7616               && t2->kind == ck_std
7617               && TREE_CODE (t1->type) == INTEGER_TYPE
7618               && TREE_CODE (t2->type) == INTEGER_TYPE
7619               && (TYPE_PRECISION (t1->type)
7620                   == TYPE_PRECISION (t2->type))
7621               && (TYPE_UNSIGNED (t1->u.next->type)
7622                   || (TREE_CODE (t1->u.next->type)
7623                       == ENUMERAL_TYPE)))
7624             {
7625               tree type = t1->u.next->type;
7626               tree type1, type2;
7627               struct z_candidate *w, *l;
7628               if (comp > 0)
7629                 type1 = t1->type, type2 = t2->type,
7630                   w = cand1, l = cand2;
7631               else
7632                 type1 = t2->type, type2 = t1->type,
7633                   w = cand2, l = cand1;
7634
7635               if (warn)
7636                 {
7637                   warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
7638                            type, type1, type2);
7639                   warning (OPT_Wsign_promo, "  in call to %qD", w->fn);
7640                 }
7641               else
7642                 add_warning (w, l);
7643             }
7644
7645           if (winner && comp != winner)
7646             {
7647               winner = 0;
7648               goto tweak;
7649             }
7650           winner = comp;
7651         }
7652     }
7653
7654   /* warn about confusing overload resolution for user-defined conversions,
7655      either between a constructor and a conversion op, or between two
7656      conversion ops.  */
7657   if (winner && warn_conversion && cand1->second_conv
7658       && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
7659       && winner != compare_ics (cand1->second_conv, cand2->second_conv))
7660     {
7661       struct z_candidate *w, *l;
7662       bool give_warning = false;
7663
7664       if (winner == 1)
7665         w = cand1, l = cand2;
7666       else
7667         w = cand2, l = cand1;
7668
7669       /* We don't want to complain about `X::operator T1 ()'
7670          beating `X::operator T2 () const', when T2 is a no less
7671          cv-qualified version of T1.  */
7672       if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
7673           && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
7674         {
7675           tree t = TREE_TYPE (TREE_TYPE (l->fn));
7676           tree f = TREE_TYPE (TREE_TYPE (w->fn));
7677
7678           if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
7679             {
7680               t = TREE_TYPE (t);
7681               f = TREE_TYPE (f);
7682             }
7683           if (!comp_ptr_ttypes (t, f))
7684             give_warning = true;
7685         }
7686       else
7687         give_warning = true;
7688
7689       if (!give_warning)
7690         /*NOP*/;
7691       else if (warn)
7692         {
7693           tree source = source_type (w->convs[0]);
7694           if (! DECL_CONSTRUCTOR_P (w->fn))
7695             source = TREE_TYPE (source);
7696           if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn)
7697               && warning (OPT_Wconversion, "  for conversion from %qT to %qT",
7698                           source, w->second_conv->type))
7699             {
7700               inform (input_location, "  because conversion sequence for the argument is better");
7701             }
7702         }
7703       else
7704         add_warning (w, l);
7705     }
7706
7707   if (winner)
7708     return winner;
7709
7710   /* or, if not that,
7711      F1 is a non-template function and F2 is a template function
7712      specialization.  */
7713
7714   if (!cand1->template_decl && cand2->template_decl)
7715     return 1;
7716   else if (cand1->template_decl && !cand2->template_decl)
7717     return -1;
7718
7719   /* or, if not that,
7720      F1 and F2 are template functions and the function template for F1 is
7721      more specialized than the template for F2 according to the partial
7722      ordering rules.  */
7723
7724   if (cand1->template_decl && cand2->template_decl)
7725     {
7726       winner = more_specialized_fn
7727         (TI_TEMPLATE (cand1->template_decl),
7728          TI_TEMPLATE (cand2->template_decl),
7729          /* [temp.func.order]: The presence of unused ellipsis and default
7730             arguments has no effect on the partial ordering of function
7731             templates.   add_function_candidate() will not have
7732             counted the "this" argument for constructors.  */
7733          cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
7734       if (winner)
7735         return winner;
7736     }
7737
7738   /* or, if not that,
7739      the  context  is  an  initialization by user-defined conversion (see
7740      _dcl.init_  and  _over.match.user_)  and  the  standard   conversion
7741      sequence  from  the return type of F1 to the destination type (i.e.,
7742      the type of the entity being initialized)  is  a  better  conversion
7743      sequence  than the standard conversion sequence from the return type
7744      of F2 to the destination type.  */
7745
7746   if (cand1->second_conv)
7747     {
7748       winner = compare_ics (cand1->second_conv, cand2->second_conv);
7749       if (winner)
7750         return winner;
7751     }
7752
7753   /* Check whether we can discard a builtin candidate, either because we
7754      have two identical ones or matching builtin and non-builtin candidates.
7755
7756      (Pedantically in the latter case the builtin which matched the user
7757      function should not be added to the overload set, but we spot it here.
7758
7759      [over.match.oper]
7760      ... the builtin candidates include ...
7761      - do not have the same parameter type list as any non-template
7762        non-member candidate.  */
7763
7764   if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
7765       || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
7766     {
7767       for (i = 0; i < len; ++i)
7768         if (!same_type_p (cand1->convs[i]->type,
7769                           cand2->convs[i]->type))
7770           break;
7771       if (i == cand1->num_convs)
7772         {
7773           if (cand1->fn == cand2->fn)
7774             /* Two built-in candidates; arbitrarily pick one.  */
7775             return 1;
7776           else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
7777             /* cand1 is built-in; prefer cand2.  */
7778             return -1;
7779           else
7780             /* cand2 is built-in; prefer cand1.  */
7781             return 1;
7782         }
7783     }
7784
7785   /* If the two function declarations represent the same function (this can
7786      happen with declarations in multiple scopes and arg-dependent lookup),
7787      arbitrarily choose one.  But first make sure the default args we're
7788      using match.  */
7789   if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
7790       && equal_functions (cand1->fn, cand2->fn))
7791     {
7792       tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn));
7793       tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn));
7794
7795       gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn));
7796
7797       for (i = 0; i < len; ++i)
7798         {
7799           /* Don't crash if the fn is variadic.  */
7800           if (!parms1)
7801             break;
7802           parms1 = TREE_CHAIN (parms1);
7803           parms2 = TREE_CHAIN (parms2);
7804         }
7805
7806       if (off1)
7807         parms1 = TREE_CHAIN (parms1);
7808       else if (off2)
7809         parms2 = TREE_CHAIN (parms2);
7810
7811       for (; parms1; ++i)
7812         {
7813           if (!cp_tree_equal (TREE_PURPOSE (parms1),
7814                               TREE_PURPOSE (parms2)))
7815             {
7816               if (warn)
7817                 {
7818                   permerror (input_location, "default argument mismatch in "
7819                              "overload resolution");
7820                   inform (input_location,
7821                           " candidate 1: %q+#F", cand1->fn);
7822                   inform (input_location,
7823                           " candidate 2: %q+#F", cand2->fn);
7824                 }
7825               else
7826                 add_warning (cand1, cand2);
7827               break;
7828             }
7829           parms1 = TREE_CHAIN (parms1);
7830           parms2 = TREE_CHAIN (parms2);
7831         }
7832
7833       return 1;
7834     }
7835
7836 tweak:
7837
7838   /* Extension: If the worst conversion for one candidate is worse than the
7839      worst conversion for the other, take the first.  */
7840   if (!pedantic)
7841     {
7842       conversion_rank rank1 = cr_identity, rank2 = cr_identity;
7843       struct z_candidate *w = 0, *l = 0;
7844
7845       for (i = 0; i < len; ++i)
7846         {
7847           if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
7848             rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
7849           if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
7850             rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
7851         }
7852       if (rank1 < rank2)
7853         winner = 1, w = cand1, l = cand2;
7854       if (rank1 > rank2)
7855         winner = -1, w = cand2, l = cand1;
7856       if (winner)
7857         {
7858           /* Don't choose a deleted function over ambiguity.  */
7859           if (DECL_P (w->fn) && DECL_DELETED_FN (w->fn))
7860             return 0;
7861           if (warn)
7862             {
7863               pedwarn (input_location, 0,
7864               "ISO C++ says that these are ambiguous, even "
7865               "though the worst conversion for the first is better than "
7866               "the worst conversion for the second:");
7867               print_z_candidate (_("candidate 1:"), w);
7868               print_z_candidate (_("candidate 2:"), l);
7869             }
7870           else
7871             add_warning (w, l);
7872           return winner;
7873         }
7874     }
7875
7876   gcc_assert (!winner);
7877   return 0;
7878 }
7879
7880 /* Given a list of candidates for overloading, find the best one, if any.
7881    This algorithm has a worst case of O(2n) (winner is last), and a best
7882    case of O(n/2) (totally ambiguous); much better than a sorting
7883    algorithm.  */
7884
7885 static struct z_candidate *
7886 tourney (struct z_candidate *candidates)
7887 {
7888   struct z_candidate *champ = candidates, *challenger;
7889   int fate;
7890   int champ_compared_to_predecessor = 0;
7891
7892   /* Walk through the list once, comparing each current champ to the next
7893      candidate, knocking out a candidate or two with each comparison.  */
7894
7895   for (challenger = champ->next; challenger; )
7896     {
7897       fate = joust (champ, challenger, 0);
7898       if (fate == 1)
7899         challenger = challenger->next;
7900       else
7901         {
7902           if (fate == 0)
7903             {
7904               champ = challenger->next;
7905               if (champ == 0)
7906                 return NULL;
7907               champ_compared_to_predecessor = 0;
7908             }
7909           else
7910             {
7911               champ = challenger;
7912               champ_compared_to_predecessor = 1;
7913             }
7914
7915           challenger = champ->next;
7916         }
7917     }
7918
7919   /* Make sure the champ is better than all the candidates it hasn't yet
7920      been compared to.  */
7921
7922   for (challenger = candidates;
7923        challenger != champ
7924          && !(champ_compared_to_predecessor && challenger->next == champ);
7925        challenger = challenger->next)
7926     {
7927       fate = joust (champ, challenger, 0);
7928       if (fate != 1)
7929         return NULL;
7930     }
7931
7932   return champ;
7933 }
7934
7935 /* Returns nonzero if things of type FROM can be converted to TO.  */
7936
7937 bool
7938 can_convert (tree to, tree from)
7939 {
7940   return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT);
7941 }
7942
7943 /* Returns nonzero if ARG (of type FROM) can be converted to TO.  */
7944
7945 bool
7946 can_convert_arg (tree to, tree from, tree arg, int flags)
7947 {
7948   conversion *t;
7949   void *p;
7950   bool ok_p;
7951
7952   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7953   p = conversion_obstack_alloc (0);
7954
7955   t  = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7956                             flags);
7957   ok_p = (t && !t->bad_p);
7958
7959   /* Free all the conversions we allocated.  */
7960   obstack_free (&conversion_obstack, p);
7961
7962   return ok_p;
7963 }
7964
7965 /* Like can_convert_arg, but allows dubious conversions as well.  */
7966
7967 bool
7968 can_convert_arg_bad (tree to, tree from, tree arg, int flags)
7969 {
7970   conversion *t;
7971   void *p;
7972
7973   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
7974   p = conversion_obstack_alloc (0);
7975   /* Try to perform the conversion.  */
7976   t  = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
7977                             flags);
7978   /* Free all the conversions we allocated.  */
7979   obstack_free (&conversion_obstack, p);
7980
7981   return t != NULL;
7982 }
7983
7984 /* Convert EXPR to TYPE.  Return the converted expression.
7985
7986    Note that we allow bad conversions here because by the time we get to
7987    this point we are committed to doing the conversion.  If we end up
7988    doing a bad conversion, convert_like will complain.  */
7989
7990 tree
7991 perform_implicit_conversion_flags (tree type, tree expr, tsubst_flags_t complain, int flags)
7992 {
7993   conversion *conv;
7994   void *p;
7995
7996   if (error_operand_p (expr))
7997     return error_mark_node;
7998
7999   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
8000   p = conversion_obstack_alloc (0);
8001
8002   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
8003                               /*c_cast_p=*/false,
8004                               flags);
8005
8006   if (!conv)
8007     {
8008       if (complain & tf_error)
8009         {
8010           /* If expr has unknown type, then it is an overloaded function.
8011              Call instantiate_type to get good error messages.  */
8012           if (TREE_TYPE (expr) == unknown_type_node)
8013             instantiate_type (type, expr, complain);
8014           else if (invalid_nonstatic_memfn_p (expr, complain))
8015             /* We gave an error.  */;
8016           else
8017             error ("could not convert %qE to %qT", expr, type);
8018         }
8019       expr = error_mark_node;
8020     }
8021   else if (processing_template_decl)
8022     {
8023       /* In a template, we are only concerned about determining the
8024          type of non-dependent expressions, so we do not have to
8025          perform the actual conversion.  */
8026       if (TREE_TYPE (expr) != type)
8027         expr = build_nop (type, expr);
8028     }
8029   else
8030     expr = convert_like (conv, expr, complain);
8031
8032   /* Free all the conversions we allocated.  */
8033   obstack_free (&conversion_obstack, p);
8034
8035   return expr;
8036 }
8037
8038 tree
8039 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
8040 {
8041   return perform_implicit_conversion_flags (type, expr, complain, LOOKUP_IMPLICIT);
8042 }
8043
8044 /* Convert EXPR to TYPE (as a direct-initialization) if that is
8045    permitted.  If the conversion is valid, the converted expression is
8046    returned.  Otherwise, NULL_TREE is returned, except in the case
8047    that TYPE is a class type; in that case, an error is issued.  If
8048    C_CAST_P is true, then this direction initialization is taking
8049    place as part of a static_cast being attempted as part of a C-style
8050    cast.  */
8051
8052 tree
8053 perform_direct_initialization_if_possible (tree type,
8054                                            tree expr,
8055                                            bool c_cast_p,
8056                                            tsubst_flags_t complain)
8057 {
8058   conversion *conv;
8059   void *p;
8060
8061   if (type == error_mark_node || error_operand_p (expr))
8062     return error_mark_node;
8063   /* [dcl.init]
8064
8065      If the destination type is a (possibly cv-qualified) class type:
8066
8067      -- If the initialization is direct-initialization ...,
8068      constructors are considered. ... If no constructor applies, or
8069      the overload resolution is ambiguous, the initialization is
8070      ill-formed.  */
8071   if (CLASS_TYPE_P (type))
8072     {
8073       VEC(tree,gc) *args = make_tree_vector_single (expr);
8074       expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
8075                                         &args, type, LOOKUP_NORMAL, complain);
8076       release_tree_vector (args);
8077       return build_cplus_new (type, expr);
8078     }
8079
8080   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
8081   p = conversion_obstack_alloc (0);
8082
8083   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
8084                               c_cast_p,
8085                               LOOKUP_NORMAL);
8086   if (!conv || conv->bad_p)
8087     expr = NULL_TREE;
8088   else
8089     expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
8090                               /*issue_conversion_warnings=*/false,
8091                               c_cast_p,
8092                               complain);
8093
8094   /* Free all the conversions we allocated.  */
8095   obstack_free (&conversion_obstack, p);
8096
8097   return expr;
8098 }
8099
8100 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE.  The reference
8101    is being bound to a temporary.  Create and return a new VAR_DECL
8102    with the indicated TYPE; this variable will store the value to
8103    which the reference is bound.  */
8104
8105 tree
8106 make_temporary_var_for_ref_to_temp (tree decl, tree type)
8107 {
8108   tree var;
8109
8110   /* Create the variable.  */
8111   var = create_temporary_var (type);
8112
8113   /* Register the variable.  */
8114   if (TREE_STATIC (decl))
8115     {
8116       /* Namespace-scope or local static; give it a mangled name.  */
8117       tree name;
8118
8119       TREE_STATIC (var) = 1;
8120       name = mangle_ref_init_variable (decl);
8121       DECL_NAME (var) = name;
8122       SET_DECL_ASSEMBLER_NAME (var, name);
8123       var = pushdecl_top_level (var);
8124     }
8125   else
8126     /* Create a new cleanup level if necessary.  */
8127     maybe_push_cleanup_level (type);
8128
8129   return var;
8130 }
8131
8132 /* EXPR is the initializer for a variable DECL of reference or
8133    std::initializer_list type.  Create, push and return a new VAR_DECL
8134    for the initializer so that it will live as long as DECL.  Any
8135    cleanup for the new variable is returned through CLEANUP, and the
8136    code to initialize the new variable is returned through INITP.  */
8137
8138 tree
8139 set_up_extended_ref_temp (tree decl, tree expr, tree *cleanup, tree *initp)
8140 {
8141   tree init;
8142   tree type;
8143   tree var;
8144
8145   /* Create the temporary variable.  */
8146   type = TREE_TYPE (expr);
8147   var = make_temporary_var_for_ref_to_temp (decl, type);
8148   layout_decl (var, 0);
8149   /* If the rvalue is the result of a function call it will be
8150      a TARGET_EXPR.  If it is some other construct (such as a
8151      member access expression where the underlying object is
8152      itself the result of a function call), turn it into a
8153      TARGET_EXPR here.  It is important that EXPR be a
8154      TARGET_EXPR below since otherwise the INIT_EXPR will
8155      attempt to make a bitwise copy of EXPR to initialize
8156      VAR.  */
8157   if (TREE_CODE (expr) != TARGET_EXPR)
8158     expr = get_target_expr (expr);
8159
8160   /* If the initializer is constant, put it in DECL_INITIAL so we get
8161      static initialization and use in constant expressions.  */
8162   init = maybe_constant_init (expr);
8163   if (TREE_CONSTANT (init))
8164     {
8165       if (literal_type_p (type) && CP_TYPE_CONST_NON_VOLATILE_P (type))
8166         {
8167           /* 5.19 says that a constant expression can include an
8168              lvalue-rvalue conversion applied to "a glvalue of literal type
8169              that refers to a non-volatile temporary object initialized
8170              with a constant expression".  Rather than try to communicate
8171              that this VAR_DECL is a temporary, just mark it constexpr.
8172
8173              Currently this is only useful for initializer_list temporaries,
8174              since reference vars can't appear in constant expressions.  */
8175           DECL_DECLARED_CONSTEXPR_P (var) = true;
8176           DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var) = true;
8177           TREE_CONSTANT (var) = true;
8178         }
8179       DECL_INITIAL (var) = init;
8180       init = NULL_TREE;
8181     }
8182   else
8183     /* Create the INIT_EXPR that will initialize the temporary
8184        variable.  */
8185     init = build2 (INIT_EXPR, type, var, expr);
8186   if (at_function_scope_p ())
8187     {
8188       add_decl_expr (var);
8189
8190       if (TREE_STATIC (var))
8191         init = add_stmt_to_compound (init, register_dtor_fn (var));
8192       else
8193         *cleanup = cxx_maybe_build_cleanup (var);
8194
8195       /* We must be careful to destroy the temporary only
8196          after its initialization has taken place.  If the
8197          initialization throws an exception, then the
8198          destructor should not be run.  We cannot simply
8199          transform INIT into something like:
8200
8201          (INIT, ({ CLEANUP_STMT; }))
8202
8203          because emit_local_var always treats the
8204          initializer as a full-expression.  Thus, the
8205          destructor would run too early; it would run at the
8206          end of initializing the reference variable, rather
8207          than at the end of the block enclosing the
8208          reference variable.
8209
8210          The solution is to pass back a cleanup expression
8211          which the caller is responsible for attaching to
8212          the statement tree.  */
8213     }
8214   else
8215     {
8216       rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
8217       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8218         static_aggregates = tree_cons (NULL_TREE, var,
8219                                        static_aggregates);
8220     }
8221
8222   *initp = init;
8223   return var;
8224 }
8225
8226 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
8227    initializing a variable of that TYPE.  If DECL is non-NULL, it is
8228    the VAR_DECL being initialized with the EXPR.  (In that case, the
8229    type of DECL will be TYPE.)  If DECL is non-NULL, then CLEANUP must
8230    also be non-NULL, and with *CLEANUP initialized to NULL.  Upon
8231    return, if *CLEANUP is no longer NULL, it will be an expression
8232    that should be pushed as a cleanup after the returned expression
8233    is used to initialize DECL.
8234
8235    Return the converted expression.  */
8236
8237 tree
8238 initialize_reference (tree type, tree expr, tree decl, tree *cleanup,
8239                       tsubst_flags_t complain)
8240 {
8241   conversion *conv;
8242   void *p;
8243
8244   if (type == error_mark_node || error_operand_p (expr))
8245     return error_mark_node;
8246
8247   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
8248   p = conversion_obstack_alloc (0);
8249
8250   conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
8251                             LOOKUP_NORMAL);
8252   if (!conv || conv->bad_p)
8253     {
8254       if (complain & tf_error)
8255         {
8256           if (!CP_TYPE_CONST_P (TREE_TYPE (type))
8257               && !TYPE_REF_IS_RVALUE (type)
8258               && !real_lvalue_p (expr))
8259             error ("invalid initialization of non-const reference of "
8260                    "type %qT from an rvalue of type %qT",
8261                    type, TREE_TYPE (expr));
8262           else
8263             error ("invalid initialization of reference of type "
8264                    "%qT from expression of type %qT", type,
8265                    TREE_TYPE (expr));
8266         }
8267       return error_mark_node;
8268     }
8269
8270   /* If DECL is non-NULL, then this special rule applies:
8271
8272        [class.temporary]
8273
8274        The temporary to which the reference is bound or the temporary
8275        that is the complete object to which the reference is bound
8276        persists for the lifetime of the reference.
8277
8278        The temporaries created during the evaluation of the expression
8279        initializing the reference, except the temporary to which the
8280        reference is bound, are destroyed at the end of the
8281        full-expression in which they are created.
8282
8283      In that case, we store the converted expression into a new
8284      VAR_DECL in a new scope.
8285
8286      However, we want to be careful not to create temporaries when
8287      they are not required.  For example, given:
8288
8289        struct B {};
8290        struct D : public B {};
8291        D f();
8292        const B& b = f();
8293
8294      there is no need to copy the return value from "f"; we can just
8295      extend its lifetime.  Similarly, given:
8296
8297        struct S {};
8298        struct T { operator S(); };
8299        T t;
8300        const S& s = t;
8301
8302     we can extend the lifetime of the return value of the conversion
8303     operator.  */
8304   gcc_assert (conv->kind == ck_ref_bind);
8305   if (decl)
8306     {
8307       tree var;
8308       tree base_conv_type;
8309
8310       /* Skip over the REF_BIND.  */
8311       conv = conv->u.next;
8312       /* If the next conversion is a BASE_CONV, skip that too -- but
8313          remember that the conversion was required.  */
8314       if (conv->kind == ck_base)
8315         {
8316           base_conv_type = conv->type;
8317           conv = conv->u.next;
8318         }
8319       else
8320         base_conv_type = NULL_TREE;
8321       /* Perform the remainder of the conversion.  */
8322       expr = convert_like_real (conv, expr,
8323                                 /*fn=*/NULL_TREE, /*argnum=*/0,
8324                                 /*inner=*/-1,
8325                                 /*issue_conversion_warnings=*/true,
8326                                 /*c_cast_p=*/false,
8327                                 tf_warning_or_error);
8328       if (error_operand_p (expr))
8329         expr = error_mark_node;
8330       else
8331         {
8332           if (!lvalue_or_rvalue_with_address_p (expr))
8333             {
8334               tree init;
8335               var = set_up_extended_ref_temp (decl, expr, cleanup, &init);
8336               /* Use its address to initialize the reference variable.  */
8337               expr = build_address (var);
8338               if (base_conv_type)
8339                 expr = convert_to_base (expr,
8340                                         build_pointer_type (base_conv_type),
8341                                         /*check_access=*/true,
8342                                         /*nonnull=*/true, complain);
8343               if (init)
8344                 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
8345             }
8346           else
8347             /* Take the address of EXPR.  */
8348             expr = cp_build_addr_expr (expr, tf_warning_or_error);
8349           /* If a BASE_CONV was required, perform it now.  */
8350           if (base_conv_type)
8351             expr = (perform_implicit_conversion
8352                     (build_pointer_type (base_conv_type), expr,
8353                      tf_warning_or_error));
8354           expr = build_nop (type, expr);
8355         }
8356     }
8357   else
8358     /* Perform the conversion.  */
8359     expr = convert_like (conv, expr, tf_warning_or_error);
8360
8361   /* Free all the conversions we allocated.  */
8362   obstack_free (&conversion_obstack, p);
8363
8364   return expr;
8365 }
8366
8367 /* Returns true iff TYPE is some variant of std::initializer_list.  */
8368
8369 bool
8370 is_std_init_list (tree type)
8371 {
8372   /* Look through typedefs.  */
8373   if (!TYPE_P (type))
8374     return false;
8375   type = TYPE_MAIN_VARIANT (type);
8376   return (CLASS_TYPE_P (type)
8377           && CP_TYPE_CONTEXT (type) == std_node
8378           && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0);
8379 }
8380
8381 /* Returns true iff DECL is a list constructor: i.e. a constructor which
8382    will accept an argument list of a single std::initializer_list<T>.  */
8383
8384 bool
8385 is_list_ctor (tree decl)
8386 {
8387   tree args = FUNCTION_FIRST_USER_PARMTYPE (decl);
8388   tree arg;
8389
8390   if (!args || args == void_list_node)
8391     return false;
8392
8393   arg = non_reference (TREE_VALUE (args));
8394   if (!is_std_init_list (arg))
8395     return false;
8396
8397   args = TREE_CHAIN (args);
8398
8399   if (args && args != void_list_node && !TREE_PURPOSE (args))
8400     /* There are more non-defaulted parms.  */
8401     return false;
8402
8403   return true;
8404 }
8405
8406 #include "gt-cp-call.h"