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