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