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