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