contrib/gcc/cp/call.c

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