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