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