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