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