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