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