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