gcc/cp/call.c

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