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