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