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    If PLACEMENT is non-NULL, then ALLOC_FN is the allocation function
3989    called to perform the placement new.  */
3990
3991 tree
3992 build_op_delete_call (enum tree_code code, tree addr, tree size,
3993                       bool global_p, tree placement,
3994                       tree alloc_fn)
3995 {
3996   tree fn = NULL_TREE;
3997   tree fns, fnname, argtypes, args, type;
3998   int pass;
3999
4000   if (addr == error_mark_node)
4001     return error_mark_node;
4002
4003   type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4004
4005   fnname = ansi_opname (code);
4006
4007   if (CLASS_TYPE_P (type)
4008       && COMPLETE_TYPE_P (complete_type (type))
4009       && !global_p)
4010     /* In [class.free]
4011
4012        If the result of the lookup is ambiguous or inaccessible, or if
4013        the lookup selects a placement deallocation function, the
4014        program is ill-formed.
4015
4016        Therefore, we ask lookup_fnfields to complain about ambiguity.  */
4017     {
4018       fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4019       if (fns == error_mark_node)
4020         return error_mark_node;
4021     }
4022   else
4023     fns = NULL_TREE;
4024
4025   if (fns == NULL_TREE)
4026     fns = lookup_name_nonclass (fnname);
4027
4028   if (placement)
4029     {
4030       /* Get the parameter types for the allocation function that is
4031          being called.  */
4032       gcc_assert (alloc_fn != NULL_TREE);
4033       argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4034       /* Also the second argument.  */
4035       args = TREE_CHAIN (TREE_OPERAND (placement, 1));
4036     }
4037   else
4038     {
4039       /* First try it without the size argument.  */
4040       argtypes = void_list_node;
4041       args = NULL_TREE;
4042     }
4043
4044   /* Strip const and volatile from addr.  */
4045   addr = cp_convert (ptr_type_node, addr);
4046
4047   /* We make two tries at finding a matching `operator delete'.  On
4048      the first pass, we look for a one-operator (or placement)
4049      operator delete.  If we're not doing placement delete, then on
4050      the second pass we look for a two-argument delete.  */
4051   for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4052     {
4053       /* Go through the `operator delete' functions looking for one
4054          with a matching type.  */
4055       for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4056            fn;
4057            fn = OVL_NEXT (fn))
4058         {
4059           tree t;
4060
4061           /* The first argument must be "void *".  */
4062           t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4063           if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4064             continue;
4065           t = TREE_CHAIN (t);
4066           /* On the first pass, check the rest of the arguments.  */
4067           if (pass == 0)
4068             {
4069               tree a = argtypes;
4070               while (a && t)
4071                 {
4072                   if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4073                     break;
4074                   a = TREE_CHAIN (a);
4075                   t = TREE_CHAIN (t);
4076                 }
4077               if (!a && !t)
4078                 break;
4079             }
4080           /* On the second pass, the second argument must be
4081              "size_t".  */
4082           else if (pass == 1
4083                    && same_type_p (TREE_VALUE (t), sizetype)
4084                    && TREE_CHAIN (t) == void_list_node)
4085             break;
4086         }
4087
4088       /* If we found a match, we're done.  */
4089       if (fn)
4090         break;
4091     }
4092
4093   /* If we have a matching function, call it.  */
4094   if (fn)
4095     {
4096       /* Make sure we have the actual function, and not an
4097          OVERLOAD.  */
4098       fn = OVL_CURRENT (fn);
4099
4100       /* If the FN is a member function, make sure that it is
4101          accessible.  */
4102       if (DECL_CLASS_SCOPE_P (fn))
4103         perform_or_defer_access_check (TYPE_BINFO (type), fn, fn);
4104
4105       if (pass == 0)
4106         args = tree_cons (NULL_TREE, addr, args);
4107       else
4108         args = tree_cons (NULL_TREE, addr,
4109                           build_tree_list (NULL_TREE, size));
4110
4111       if (placement)
4112         {
4113           /* The placement args might not be suitable for overload
4114              resolution at this point, so build the call directly.  */
4115           mark_used (fn);
4116           return build_cxx_call (fn, args);
4117         }
4118       else
4119         return build_function_call (fn, args);
4120     }
4121
4122   /* If we are doing placement delete we do nothing if we don't find a
4123      matching op delete.  */
4124   if (placement)
4125     return NULL_TREE;
4126
4127   error ("no suitable %<operator %s%> for %qT",
4128          operator_name_info[(int)code].name, type);
4129   return error_mark_node;
4130 }
4131
4132 /* If the current scope isn't allowed to access DECL along
4133    BASETYPE_PATH, give an error.  The most derived class in
4134    BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4135    the declaration to use in the error diagnostic.  */
4136
4137 bool
4138 enforce_access (tree basetype_path, tree decl, tree diag_decl)
4139 {
4140   gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4141
4142   if (!accessible_p (basetype_path, decl, true))
4143     {
4144       if (TREE_PRIVATE (decl))
4145         error ("%q+#D is private", diag_decl);
4146       else if (TREE_PROTECTED (decl))
4147         error ("%q+#D is protected", diag_decl);
4148       else
4149         error ("%q+#D is inaccessible", diag_decl);
4150       error ("within this context");
4151       return false;
4152     }
4153
4154   return true;
4155 }
4156
4157 /* Check that a callable constructor to initialize a temporary of
4158    TYPE from an EXPR exists.  */
4159
4160 static void
4161 check_constructor_callable (tree type, tree expr)
4162 {
4163   build_special_member_call (NULL_TREE,
4164                              complete_ctor_identifier,
4165                              build_tree_list (NULL_TREE, expr),
4166                              type,
4167                              LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
4168                              | LOOKUP_NO_CONVERSION
4169                              | LOOKUP_CONSTRUCTOR_CALLABLE);
4170 }
4171
4172 /* Initialize a temporary of type TYPE with EXPR.  The FLAGS are a
4173    bitwise or of LOOKUP_* values.  If any errors are warnings are
4174    generated, set *DIAGNOSTIC_FN to "error" or "warning",
4175    respectively.  If no diagnostics are generated, set *DIAGNOSTIC_FN
4176    to NULL.  */
4177
4178 static tree
4179 build_temp (tree expr, tree type, int flags,
4180             diagnostic_fn_t *diagnostic_fn)
4181 {
4182   int savew, savee;
4183
4184   savew = warningcount, savee = errorcount;
4185   expr = build_special_member_call (NULL_TREE,
4186                                     complete_ctor_identifier,
4187                                     build_tree_list (NULL_TREE, expr),
4188                                     type, flags);
4189   if (warningcount > savew)
4190     *diagnostic_fn = warning0;
4191   else if (errorcount > savee)
4192     *diagnostic_fn = error;
4193   else
4194     *diagnostic_fn = NULL;
4195   return expr;
4196 }
4197
4198
4199 /* Perform the conversions in CONVS on the expression EXPR.  FN and
4200    ARGNUM are used for diagnostics.  ARGNUM is zero based, -1
4201    indicates the `this' argument of a method.  INNER is nonzero when
4202    being called to continue a conversion chain. It is negative when a
4203    reference binding will be applied, positive otherwise.  If
4204    ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4205    conversions will be emitted if appropriate.  If C_CAST_P is true,
4206    this conversion is coming from a C-style cast; in that case,
4207    conversions to inaccessible bases are permitted.  */
4208
4209 static tree
4210 convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4211                    int inner, bool issue_conversion_warnings,
4212                    bool c_cast_p)
4213 {
4214   tree totype = convs->type;
4215   diagnostic_fn_t diagnostic_fn;
4216
4217   if (convs->bad_p
4218       && convs->kind != ck_user
4219       && convs->kind != ck_ambig
4220       && convs->kind != ck_ref_bind)
4221     {
4222       conversion *t = convs;
4223       for (; t; t = convs->u.next)
4224         {
4225           if (t->kind == ck_user || !t->bad_p)
4226             {
4227               expr = convert_like_real (t, expr, fn, argnum, 1,
4228                                         /*issue_conversion_warnings=*/false,
4229                                         /*c_cast_p=*/false);
4230               break;
4231             }
4232           else if (t->kind == ck_ambig)
4233             return convert_like_real (t, expr, fn, argnum, 1,
4234                                       /*issue_conversion_warnings=*/false,
4235                                       /*c_cast_p=*/false);
4236           else if (t->kind == ck_identity)
4237             break;
4238         }
4239       pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4240       if (fn)
4241         pedwarn ("  initializing argument %P of %qD", argnum, fn);
4242       return cp_convert (totype, expr);
4243     }
4244
4245   if (issue_conversion_warnings)
4246     {
4247       tree t = non_reference (totype);
4248
4249       /* Issue warnings about peculiar, but valid, uses of NULL.  */
4250       if (ARITHMETIC_TYPE_P (t) && expr == null_node)
4251         {
4252           if (fn)
4253             warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD",
4254                      argnum, fn);
4255           else
4256             warning (OPT_Wconversion, "converting to non-pointer type %qT from NULL", t);
4257         }
4258
4259       /* Warn about assigning a floating-point type to an integer type.  */
4260       if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
4261           && TREE_CODE (t) == INTEGER_TYPE)
4262         {
4263           if (fn)
4264             warning (OPT_Wconversion, "passing %qT for argument %P to %qD",
4265                      TREE_TYPE (expr), argnum, fn);
4266           else
4267             warning (OPT_Wconversion, "converting to %qT from %qT", t, TREE_TYPE (expr));
4268         }
4269     }
4270
4271   switch (convs->kind)
4272     {
4273     case ck_user:
4274       {
4275         struct z_candidate *cand = convs->cand;
4276         tree convfn = cand->fn;
4277         tree args;
4278
4279         if (DECL_CONSTRUCTOR_P (convfn))
4280           {
4281             tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
4282                                     0);
4283
4284             args = build_tree_list (NULL_TREE, expr);
4285             /* We should never try to call the abstract or base constructor
4286                from here.  */
4287             gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn)
4288                         && !DECL_HAS_VTT_PARM_P (convfn));
4289             args = tree_cons (NULL_TREE, t, args);
4290           }
4291         else
4292           args = build_this (expr);
4293         expr = build_over_call (cand, LOOKUP_NORMAL);
4294
4295         /* If this is a constructor or a function returning an aggr type,
4296            we need to build up a TARGET_EXPR.  */
4297         if (DECL_CONSTRUCTOR_P (convfn))
4298           expr = build_cplus_new (totype, expr);
4299
4300         /* The result of the call is then used to direct-initialize the object
4301            that is the destination of the copy-initialization.  [dcl.init]
4302
4303            Note that this step is not reflected in the conversion sequence;
4304            it affects the semantics when we actually perform the
4305            conversion, but is not considered during overload resolution.
4306
4307            If the target is a class, that means call a ctor.  */
4308         if (IS_AGGR_TYPE (totype)
4309             && (inner >= 0 || !lvalue_p (expr)))
4310           {
4311             expr = (build_temp
4312                     (expr, totype,
4313                      /* Core issue 84, now a DR, says that we don't
4314                         allow UDCs for these args (which deliberately
4315                         breaks copy-init of an auto_ptr<Base> from an
4316                         auto_ptr<Derived>).  */
4317                      LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4318                      &diagnostic_fn));
4319
4320             if (diagnostic_fn)
4321               {
4322                 if (fn)
4323                   diagnostic_fn
4324                     ("  initializing argument %P of %qD from result of %qD",
4325                      argnum, fn, convfn);
4326                 else
4327                  diagnostic_fn
4328                    ("  initializing temporary from result of %qD",  convfn);
4329               }
4330             expr = build_cplus_new (totype, expr);
4331           }
4332         return expr;
4333       }
4334     case ck_identity:
4335       if (type_unknown_p (expr))
4336         expr = instantiate_type (totype, expr, tf_warning_or_error);
4337       /* Convert a constant to its underlying value, unless we are
4338          about to bind it to a reference, in which case we need to
4339          leave it as an lvalue.  */
4340       if (inner >= 0)
4341         expr = decl_constant_value (expr);
4342       if (convs->check_copy_constructor_p)
4343         check_constructor_callable (totype, expr);
4344       return expr;
4345     case ck_ambig:
4346       /* Call build_user_type_conversion again for the error.  */
4347       return build_user_type_conversion
4348         (totype, convs->u.expr, LOOKUP_NORMAL);
4349
4350     default:
4351       break;
4352     };
4353
4354   expr = convert_like_real (convs->u.next, expr, fn, argnum,
4355                             convs->kind == ck_ref_bind ? -1 : 1,
4356                             /*issue_conversion_warnings=*/false,
4357                             c_cast_p);
4358   if (expr == error_mark_node)
4359     return error_mark_node;
4360
4361   switch (convs->kind)
4362     {
4363     case ck_rvalue:
4364       expr = convert_bitfield_to_declared_type (expr);
4365       if (! IS_AGGR_TYPE (totype))
4366         return expr;
4367       /* Else fall through.  */
4368     case ck_base:
4369       if (convs->kind == ck_base && !convs->need_temporary_p)
4370         {
4371           /* We are going to bind a reference directly to a base-class
4372              subobject of EXPR.  */
4373           if (convs->check_copy_constructor_p)
4374             check_constructor_callable (TREE_TYPE (expr), expr);
4375           /* Build an expression for `*((base*) &expr)'.  */
4376           expr = build_unary_op (ADDR_EXPR, expr, 0);
4377           expr = convert_to_base (expr, build_pointer_type (totype),
4378                                   !c_cast_p, /*nonnull=*/true);
4379           expr = build_indirect_ref (expr, "implicit conversion");
4380           return expr;
4381         }
4382
4383       /* Copy-initialization where the cv-unqualified version of the source
4384          type is the same class as, or a derived class of, the class of the
4385          destination [is treated as direct-initialization].  [dcl.init] */
4386       expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4387                          &diagnostic_fn);
4388       if (diagnostic_fn && fn)
4389         diagnostic_fn ("  initializing argument %P of %qD", argnum, fn);
4390       return build_cplus_new (totype, expr);
4391
4392     case ck_ref_bind:
4393       {
4394         tree ref_type = totype;
4395
4396         /* If necessary, create a temporary.  */
4397         if (convs->need_temporary_p || !lvalue_p (expr))
4398           {
4399             tree type = convs->u.next->type;
4400             cp_lvalue_kind lvalue = real_lvalue_p (expr);
4401
4402             if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4403               {
4404                 /* If the reference is volatile or non-const, we
4405                    cannot create a temporary.  */
4406                 if (lvalue & clk_bitfield)
4407                   error ("cannot bind bitfield %qE to %qT",
4408                          expr, ref_type);
4409                 else if (lvalue & clk_packed)
4410                   error ("cannot bind packed field %qE to %qT",
4411                          expr, ref_type);
4412                 else
4413                   error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4414                 return error_mark_node;
4415               }
4416             /* If the source is a packed field, and we must use a copy
4417                constructor, then building the target expr will require
4418                binding the field to the reference parameter to the
4419                copy constructor, and we'll end up with an infinite
4420                loop.  If we can use a bitwise copy, then we'll be
4421                OK.  */
4422             if ((lvalue & clk_packed)
4423                 && CLASS_TYPE_P (type)
4424                 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4425               {
4426                 error ("cannot bind packed field %qE to %qT",
4427                        expr, ref_type);
4428                 return error_mark_node;
4429               }
4430             expr = build_target_expr_with_type (expr, type);
4431           }
4432
4433         /* Take the address of the thing to which we will bind the
4434            reference.  */
4435         expr = build_unary_op (ADDR_EXPR, expr, 1);
4436         if (expr == error_mark_node)
4437           return error_mark_node;
4438
4439         /* Convert it to a pointer to the type referred to by the
4440            reference.  This will adjust the pointer if a derived to
4441            base conversion is being performed.  */
4442         expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4443                            expr);
4444         /* Convert the pointer to the desired reference type.  */
4445         return build_nop (ref_type, expr);
4446       }
4447
4448     case ck_lvalue:
4449       return decay_conversion (expr);
4450
4451     case ck_qual:
4452       /* Warn about deprecated conversion if appropriate.  */
4453       string_conv_p (totype, expr, 1);
4454       break;
4455
4456     case ck_ptr:
4457       if (convs->base_p)
4458         expr = convert_to_base (expr, totype, !c_cast_p,
4459                                 /*nonnull=*/false);
4460       return build_nop (totype, expr);
4461
4462     case ck_pmem:
4463       return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4464                              c_cast_p);
4465
4466     default:
4467       break;
4468     }
4469
4470   if (issue_conversion_warnings)
4471     expr = convert_and_check (totype, expr);
4472   else
4473     expr = convert (totype, expr);
4474
4475   return expr;
4476 }
4477
4478 /* Build a call to __builtin_trap.  */
4479
4480 static tree
4481 call_builtin_trap (void)
4482 {
4483   tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4484
4485   gcc_assert (fn != NULL);
4486   fn = build_call (fn, NULL_TREE);
4487   return fn;
4488 }
4489
4490 /* ARG is being passed to a varargs function.  Perform any conversions
4491    required.  Return the converted value.  */
4492
4493 tree
4494 convert_arg_to_ellipsis (tree arg)
4495 {
4496   /* [expr.call]
4497
4498      The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4499      standard conversions are performed.  */
4500   arg = decay_conversion (arg);
4501   /* [expr.call]
4502
4503      If the argument has integral or enumeration type that is subject
4504      to the integral promotions (_conv.prom_), or a floating point
4505      type that is subject to the floating point promotion
4506      (_conv.fpprom_), the value of the argument is converted to the
4507      promoted type before the call.  */
4508   if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4509       && (TYPE_PRECISION (TREE_TYPE (arg))
4510           < TYPE_PRECISION (double_type_node)))
4511     arg = convert_to_real (double_type_node, arg);
4512   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4513     arg = perform_integral_promotions (arg);
4514
4515   arg = require_complete_type (arg);
4516
4517   if (arg != error_mark_node
4518       && !pod_type_p (TREE_TYPE (arg)))
4519     {
4520       /* Undefined behavior [expr.call] 5.2.2/7.  We used to just warn
4521          here and do a bitwise copy, but now cp_expr_size will abort if we
4522          try to do that.
4523          If the call appears in the context of a sizeof expression,
4524          there is no need to emit a warning, since the expression won't be
4525          evaluated. We keep the builtin_trap just as a safety check.  */
4526       if (!skip_evaluation)
4527         warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
4528                  "call will abort at runtime", TREE_TYPE (arg));
4529       arg = call_builtin_trap ();
4530       arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4531                     integer_zero_node);
4532     }
4533
4534   return arg;
4535 }
4536
4537 /* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused.  */
4538
4539 tree
4540 build_x_va_arg (tree expr, tree type)
4541 {
4542   if (processing_template_decl)
4543     return build_min (VA_ARG_EXPR, type, expr);
4544
4545   type = complete_type_or_else (type, NULL_TREE);
4546
4547   if (expr == error_mark_node || !type)
4548     return error_mark_node;
4549
4550   if (! pod_type_p (type))
4551     {
4552       /* Remove reference types so we don't ICE later on.  */
4553       tree type1 = non_reference (type);
4554       /* Undefined behavior [expr.call] 5.2.2/7.  */
4555       warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4556                "call will abort at runtime", type);
4557       expr = convert (build_pointer_type (type1), null_node);
4558       expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4559                      call_builtin_trap (), expr);
4560       expr = build_indirect_ref (expr, NULL);
4561       return expr;
4562     }
4563
4564   return build_va_arg (expr, type);
4565 }
4566
4567 /* TYPE has been given to va_arg.  Apply the default conversions which
4568    would have happened when passed via ellipsis.  Return the promoted
4569    type, or the passed type if there is no change.  */
4570
4571 tree
4572 cxx_type_promotes_to (tree type)
4573 {
4574   tree promote;
4575
4576   /* Perform the array-to-pointer and function-to-pointer
4577      conversions.  */
4578   type = type_decays_to (type);
4579
4580   promote = type_promotes_to (type);
4581   if (same_type_p (type, promote))
4582     promote = type;
4583
4584   return promote;
4585 }
4586
4587 /* ARG is a default argument expression being passed to a parameter of
4588    the indicated TYPE, which is a parameter to FN.  Do any required
4589    conversions.  Return the converted value.  */
4590
4591 tree
4592 convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4593 {
4594   /* If the ARG is an unparsed default argument expression, the
4595      conversion cannot be performed.  */
4596   if (TREE_CODE (arg) == DEFAULT_ARG)
4597     {
4598       error ("the default argument for parameter %d of %qD has "
4599              "not yet been parsed",
4600              parmnum, fn);
4601       return error_mark_node;
4602     }
4603
4604   if (fn && DECL_TEMPLATE_INFO (fn))
4605     arg = tsubst_default_argument (fn, type, arg);
4606
4607   arg = break_out_target_exprs (arg);
4608
4609   if (TREE_CODE (arg) == CONSTRUCTOR)
4610     {
4611       arg = digest_init (type, arg);
4612       arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4613                                         "default argument", fn, parmnum);
4614     }
4615   else
4616     {
4617       /* We must make a copy of ARG, in case subsequent processing
4618          alters any part of it.  For example, during gimplification a
4619          cast of the form (T) &X::f (where "f" is a member function)
4620          will lead to replacing the PTRMEM_CST for &X::f with a
4621          VAR_DECL.  We can avoid the copy for constants, since they
4622          are never modified in place.  */
4623       if (!CONSTANT_CLASS_P (arg))
4624         arg = unshare_expr (arg);
4625       arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4626                                         "default argument", fn, parmnum);
4627       arg = convert_for_arg_passing (type, arg);
4628     }
4629
4630   return arg;
4631 }
4632
4633 /* Returns the type which will really be used for passing an argument of
4634    type TYPE.  */
4635
4636 tree
4637 type_passed_as (tree type)
4638 {
4639   /* Pass classes with copy ctors by invisible reference.  */
4640   if (TREE_ADDRESSABLE (type))
4641     {
4642       type = build_reference_type (type);
4643       /* There are no other pointers to this temporary.  */
4644       type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4645     }
4646   else if (targetm.calls.promote_prototypes (type)
4647            && INTEGRAL_TYPE_P (type)
4648            && COMPLETE_TYPE_P (type)
4649            && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4650                                    TYPE_SIZE (integer_type_node)))
4651     type = integer_type_node;
4652
4653   return type;
4654 }
4655
4656 /* Actually perform the appropriate conversion.  */
4657
4658 tree
4659 convert_for_arg_passing (tree type, tree val)
4660 {
4661   val = convert_bitfield_to_declared_type (val);
4662   if (val == error_mark_node)
4663     ;
4664   /* Pass classes with copy ctors by invisible reference.  */
4665   else if (TREE_ADDRESSABLE (type))
4666     val = build1 (ADDR_EXPR, build_reference_type (type), val);
4667   else if (targetm.calls.promote_prototypes (type)
4668            && INTEGRAL_TYPE_P (type)
4669            && COMPLETE_TYPE_P (type)
4670            && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4671                                    TYPE_SIZE (integer_type_node)))
4672     val = perform_integral_promotions (val);
4673   if (warn_missing_format_attribute)
4674     {
4675       tree rhstype = TREE_TYPE (val);
4676       const enum tree_code coder = TREE_CODE (rhstype);
4677       const enum tree_code codel = TREE_CODE (type);
4678       if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4679           && coder == codel
4680           && check_missing_format_attribute (type, rhstype))
4681         warning (OPT_Wmissing_format_attribute,
4682                  "argument of function call might be a candidate for a format attribute");
4683     }
4684   return val;
4685 }
4686
4687 /* Returns true iff FN is a function with magic varargs, i.e. ones for
4688    which no conversions at all should be done.  This is true for some
4689    builtins which don't act like normal functions.  */
4690
4691 static bool
4692 magic_varargs_p (tree fn)
4693 {
4694   if (DECL_BUILT_IN (fn))
4695     switch (DECL_FUNCTION_CODE (fn))
4696       {
4697       case BUILT_IN_CLASSIFY_TYPE:
4698       case BUILT_IN_CONSTANT_P:
4699       case BUILT_IN_NEXT_ARG:
4700       case BUILT_IN_STDARG_START:
4701       case BUILT_IN_VA_START:
4702         return true;
4703
4704       default:;
4705       }
4706
4707   return false;
4708 }
4709
4710 /* Subroutine of the various build_*_call functions.  Overload resolution
4711    has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4712    ARGS is a TREE_LIST of the unconverted arguments to the call.  FLAGS is a
4713    bitmask of various LOOKUP_* flags which apply to the call itself.  */
4714
4715 static tree
4716 build_over_call (struct z_candidate *cand, int flags)
4717 {
4718   tree fn = cand->fn;
4719   tree args = cand->args;
4720   conversion **convs = cand->convs;
4721   conversion *conv;
4722   tree converted_args = NULL_TREE;
4723   tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4724   tree arg, val;
4725   int i = 0;
4726   int is_method = 0;
4727
4728   /* In a template, there is no need to perform all of the work that
4729      is normally done.  We are only interested in the type of the call
4730      expression, i.e., the return type of the function.  Any semantic
4731      errors will be deferred until the template is instantiated.  */
4732   if (processing_template_decl)
4733     {
4734       tree expr;
4735       tree return_type;
4736       return_type = TREE_TYPE (TREE_TYPE (fn));
4737       expr = build3 (CALL_EXPR, return_type, fn, args, NULL_TREE);
4738       if (TREE_THIS_VOLATILE (fn) && cfun)
4739         current_function_returns_abnormally = 1;
4740       if (!VOID_TYPE_P (return_type))
4741         require_complete_type (return_type);
4742       return convert_from_reference (expr);
4743     }
4744
4745   /* Give any warnings we noticed during overload resolution.  */
4746   if (cand->warnings)
4747     {
4748       struct candidate_warning *w;
4749       for (w = cand->warnings; w; w = w->next)
4750         joust (cand, w->loser, 1);
4751     }
4752
4753   if (DECL_FUNCTION_MEMBER_P (fn))
4754     {
4755       /* If FN is a template function, two cases must be considered.
4756          For example:
4757
4758            struct A {
4759              protected:
4760                template <class T> void f();
4761            };
4762            template <class T> struct B {
4763              protected:
4764                void g();
4765            };
4766            struct C : A, B<int> {
4767              using A::f;        // #1
4768              using B<int>::g;   // #2
4769            };
4770
4771          In case #1 where `A::f' is a member template, DECL_ACCESS is
4772          recorded in the primary template but not in its specialization.
4773          We check access of FN using its primary template.
4774
4775          In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4776          because it is a member of class template B, DECL_ACCESS is
4777          recorded in the specialization `B<int>::g'.  We cannot use its
4778          primary template because `B<T>::g' and `B<int>::g' may have
4779          different access.  */
4780       if (DECL_TEMPLATE_INFO (fn)
4781           && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4782         perform_or_defer_access_check (cand->access_path,
4783                                        DECL_TI_TEMPLATE (fn), fn);
4784       else
4785         perform_or_defer_access_check (cand->access_path, fn, fn);
4786     }
4787
4788   if (args && TREE_CODE (args) != TREE_LIST)
4789     args = build_tree_list (NULL_TREE, args);
4790   arg = args;
4791
4792   /* The implicit parameters to a constructor are not considered by overload
4793      resolution, and must be of the proper type.  */
4794   if (DECL_CONSTRUCTOR_P (fn))
4795     {
4796       converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4797       arg = TREE_CHAIN (arg);
4798       parm = TREE_CHAIN (parm);
4799       /* We should never try to call the abstract constructor.  */
4800       gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4801
4802       if (DECL_HAS_VTT_PARM_P (fn))
4803         {
4804           converted_args = tree_cons
4805             (NULL_TREE, TREE_VALUE (arg), converted_args);
4806           arg = TREE_CHAIN (arg);
4807           parm = TREE_CHAIN (parm);
4808         }
4809     }
4810   /* Bypass access control for 'this' parameter.  */
4811   else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4812     {
4813       tree parmtype = TREE_VALUE (parm);
4814       tree argtype = TREE_TYPE (TREE_VALUE (arg));
4815       tree converted_arg;
4816       tree base_binfo;
4817
4818       if (convs[i]->bad_p)
4819         pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4820                  TREE_TYPE (argtype), fn);
4821
4822       /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4823          X is called for an object that is not of type X, or of a type
4824          derived from X, the behavior is undefined.
4825
4826          So we can assume that anything passed as 'this' is non-null, and
4827          optimize accordingly.  */
4828       gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4829       /* Convert to the base in which the function was declared.  */
4830       gcc_assert (cand->conversion_path != NULL_TREE);
4831       converted_arg = build_base_path (PLUS_EXPR,
4832                                        TREE_VALUE (arg),
4833                                        cand->conversion_path,
4834                                        1);
4835       /* Check that the base class is accessible.  */
4836       if (!accessible_base_p (TREE_TYPE (argtype),
4837                               BINFO_TYPE (cand->conversion_path), true))
4838         error ("%qT is not an accessible base of %qT",
4839                BINFO_TYPE (cand->conversion_path),
4840                TREE_TYPE (argtype));
4841       /* If fn was found by a using declaration, the conversion path
4842          will be to the derived class, not the base declaring fn. We
4843          must convert from derived to base.  */
4844       base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4845                                 TREE_TYPE (parmtype), ba_unique, NULL);
4846       converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4847                                        base_binfo, 1);
4848
4849       converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4850       parm = TREE_CHAIN (parm);
4851       arg = TREE_CHAIN (arg);
4852       ++i;
4853       is_method = 1;
4854     }
4855
4856   for (; arg && parm;
4857        parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4858     {
4859       tree type = TREE_VALUE (parm);
4860
4861       conv = convs[i];
4862
4863       /* Don't make a copy here if build_call is going to.  */
4864       if (conv->kind == ck_rvalue
4865           && !TREE_ADDRESSABLE (complete_type (type)))
4866         conv = conv->u.next;
4867
4868       val = convert_like_with_context
4869         (conv, TREE_VALUE (arg), fn, i - is_method);
4870
4871       val = convert_for_arg_passing (type, val);
4872       converted_args = tree_cons (NULL_TREE, val, converted_args);
4873     }
4874
4875   /* Default arguments */
4876   for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4877     converted_args
4878       = tree_cons (NULL_TREE,
4879                    convert_default_arg (TREE_VALUE (parm),
4880                                         TREE_PURPOSE (parm),
4881                                         fn, i - is_method),
4882                    converted_args);
4883
4884   /* Ellipsis */
4885   for (; arg; arg = TREE_CHAIN (arg))
4886     {
4887       tree a = TREE_VALUE (arg);
4888       if (magic_varargs_p (fn))
4889         /* Do no conversions for magic varargs.  */;
4890       else
4891         a = convert_arg_to_ellipsis (a);
4892       converted_args = tree_cons (NULL_TREE, a, converted_args);
4893     }
4894
4895   converted_args = nreverse (converted_args);
4896
4897   check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4898                             converted_args, TYPE_ARG_TYPES (TREE_TYPE (fn)));
4899
4900   /* Avoid actually calling copy constructors and copy assignment operators,
4901      if possible.  */
4902
4903   if (! flag_elide_constructors)
4904     /* Do things the hard way.  */;
4905   else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4906     {
4907       tree targ;
4908       arg = skip_artificial_parms_for (fn, converted_args);
4909       arg = TREE_VALUE (arg);
4910
4911       /* Pull out the real argument, disregarding const-correctness.  */
4912       targ = arg;
4913       while (TREE_CODE (targ) == NOP_EXPR
4914              || TREE_CODE (targ) == NON_LVALUE_EXPR
4915              || TREE_CODE (targ) == CONVERT_EXPR)
4916         targ = TREE_OPERAND (targ, 0);
4917       if (TREE_CODE (targ) == ADDR_EXPR)
4918         {
4919           targ = TREE_OPERAND (targ, 0);
4920           if (!same_type_ignoring_top_level_qualifiers_p
4921               (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4922             targ = NULL_TREE;
4923         }
4924       else
4925         targ = NULL_TREE;
4926
4927       if (targ)
4928         arg = targ;
4929       else
4930         arg = build_indirect_ref (arg, 0);
4931
4932       /* [class.copy]: the copy constructor is implicitly defined even if
4933          the implementation elided its use.  */
4934       if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4935         mark_used (fn);
4936
4937       /* If we're creating a temp and we already have one, don't create a
4938          new one.  If we're not creating a temp but we get one, use
4939          INIT_EXPR to collapse the temp into our target.  Otherwise, if the
4940          ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4941          temp or an INIT_EXPR otherwise.  */
4942       if (integer_zerop (TREE_VALUE (args)))
4943         {
4944           if (TREE_CODE (arg) == TARGET_EXPR)
4945             return arg;
4946           else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4947             return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4948         }
4949       else if (TREE_CODE (arg) == TARGET_EXPR
4950                || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4951         {
4952           tree to = stabilize_reference
4953             (build_indirect_ref (TREE_VALUE (args), 0));
4954
4955           val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4956           return val;
4957         }
4958     }
4959   else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4960            && copy_fn_p (fn)
4961            && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4962     {
4963       tree to = stabilize_reference
4964         (build_indirect_ref (TREE_VALUE (converted_args), 0));
4965       tree type = TREE_TYPE (to);
4966       tree as_base = CLASSTYPE_AS_BASE (type);
4967
4968       arg = TREE_VALUE (TREE_CHAIN (converted_args));
4969       if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
4970         {
4971           arg = build_indirect_ref (arg, 0);
4972           val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4973         }
4974       else
4975         {
4976           /* We must only copy the non-tail padding parts.
4977              Use __builtin_memcpy for the bitwise copy.  */
4978
4979           tree args, t;
4980
4981           args = tree_cons (NULL, TYPE_SIZE_UNIT (as_base), NULL);
4982           args = tree_cons (NULL, arg, args);
4983           t = build_unary_op (ADDR_EXPR, to, 0);
4984           args = tree_cons (NULL, t, args);
4985           t = implicit_built_in_decls[BUILT_IN_MEMCPY];
4986           t = build_call (t, args);
4987
4988           t = convert (TREE_TYPE (TREE_VALUE (args)), t);
4989           val = build_indirect_ref (t, 0);
4990         }
4991
4992       return val;
4993     }
4994
4995   mark_used (fn);
4996
4997   if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
4998     {
4999       tree t, *p = &TREE_VALUE (converted_args);
5000       tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
5001                                 DECL_CONTEXT (fn),
5002                                 ba_any, NULL);
5003       gcc_assert (binfo && binfo != error_mark_node);
5004
5005       *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
5006       if (TREE_SIDE_EFFECTS (*p))
5007         *p = save_expr (*p);
5008       t = build_pointer_type (TREE_TYPE (fn));
5009       if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5010         fn = build_java_interface_fn_ref (fn, *p);
5011       else
5012         fn = build_vfn_ref (*p, DECL_VINDEX (fn));
5013       TREE_TYPE (fn) = t;
5014     }
5015   else if (DECL_INLINE (fn))
5016     fn = inline_conversion (fn);
5017   else
5018     fn = build_addr_func (fn);
5019
5020   return build_cxx_call (fn, converted_args);
5021 }
5022
5023 /* Build and return a call to FN, using ARGS.  This function performs
5024    no overload resolution, conversion, or other high-level
5025    operations.  */
5026
5027 tree
5028 build_cxx_call (tree fn, tree args)
5029 {
5030   tree fndecl;
5031
5032   fn = build_call (fn, args);
5033
5034   /* If this call might throw an exception, note that fact.  */
5035   fndecl = get_callee_fndecl (fn);
5036   if ((!fndecl || !TREE_NOTHROW (fndecl))
5037       && at_function_scope_p ()
5038       && cfun)
5039     cp_function_chain->can_throw = 1;
5040
5041   /* Some built-in function calls will be evaluated at compile-time in
5042      fold ().  */
5043   fn = fold_if_not_in_template (fn);
5044
5045   if (VOID_TYPE_P (TREE_TYPE (fn)))
5046     return fn;
5047
5048   fn = require_complete_type (fn);
5049   if (fn == error_mark_node)
5050     return error_mark_node;
5051
5052   if (IS_AGGR_TYPE (TREE_TYPE (fn)))
5053     fn = build_cplus_new (TREE_TYPE (fn), fn);
5054   return convert_from_reference (fn);
5055 }
5056
5057 static GTY(()) tree java_iface_lookup_fn;
5058
5059 /* Make an expression which yields the address of the Java interface
5060    method FN.  This is achieved by generating a call to libjava's
5061    _Jv_LookupInterfaceMethodIdx().  */
5062
5063 static tree
5064 build_java_interface_fn_ref (tree fn, tree instance)
5065 {
5066   tree lookup_args, lookup_fn, method, idx;
5067   tree klass_ref, iface, iface_ref;
5068   int i;
5069
5070   if (!java_iface_lookup_fn)
5071     {
5072       tree endlink = build_void_list_node ();
5073       tree t = tree_cons (NULL_TREE, ptr_type_node,
5074                           tree_cons (NULL_TREE, ptr_type_node,
5075                                      tree_cons (NULL_TREE, java_int_type_node,
5076                                                 endlink)));
5077       java_iface_lookup_fn
5078         = builtin_function ("_Jv_LookupInterfaceMethodIdx",
5079                             build_function_type (ptr_type_node, t),
5080                             0, NOT_BUILT_IN, NULL, NULL_TREE);
5081     }
5082
5083   /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5084      This is the first entry in the vtable.  */
5085   klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
5086                               integer_zero_node);
5087
5088   /* Get the java.lang.Class pointer for the interface being called.  */
5089   iface = DECL_CONTEXT (fn);
5090   iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5091   if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5092       || DECL_CONTEXT (iface_ref) != iface)
5093     {
5094       error ("could not find class$ field in java interface type %qT",
5095                 iface);
5096       return error_mark_node;
5097     }
5098   iface_ref = build_address (iface_ref);
5099   iface_ref = convert (build_pointer_type (iface), iface_ref);
5100
5101   /* Determine the itable index of FN.  */
5102   i = 1;
5103   for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5104     {
5105       if (!DECL_VIRTUAL_P (method))
5106         continue;
5107       if (fn == method)
5108         break;
5109       i++;
5110     }
5111   idx = build_int_cst (NULL_TREE, i);
5112
5113   lookup_args = tree_cons (NULL_TREE, klass_ref,
5114                            tree_cons (NULL_TREE, iface_ref,
5115                                       build_tree_list (NULL_TREE, idx)));
5116   lookup_fn = build1 (ADDR_EXPR,
5117                       build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5118                       java_iface_lookup_fn);
5119   return build3 (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
5120 }
5121
5122 /* Returns the value to use for the in-charge parameter when making a
5123    call to a function with the indicated NAME.
5124
5125    FIXME:Can't we find a neater way to do this mapping?  */
5126
5127 tree
5128 in_charge_arg_for_name (tree name)
5129 {
5130  if (name == base_ctor_identifier
5131       || name == base_dtor_identifier)
5132     return integer_zero_node;
5133   else if (name == complete_ctor_identifier)
5134     return integer_one_node;
5135   else if (name == complete_dtor_identifier)
5136     return integer_two_node;
5137   else if (name == deleting_dtor_identifier)
5138     return integer_three_node;
5139
5140   /* This function should only be called with one of the names listed
5141      above.  */
5142   gcc_unreachable ();
5143   return NULL_TREE;
5144 }
5145
5146 /* Build a call to a constructor, destructor, or an assignment
5147    operator for INSTANCE, an expression with class type.  NAME
5148    indicates the special member function to call; ARGS are the
5149    arguments.  BINFO indicates the base of INSTANCE that is to be
5150    passed as the `this' parameter to the member function called.
5151
5152    FLAGS are the LOOKUP_* flags to use when processing the call.
5153
5154    If NAME indicates a complete object constructor, INSTANCE may be
5155    NULL_TREE.  In this case, the caller will call build_cplus_new to
5156    store the newly constructed object into a VAR_DECL.  */
5157
5158 tree
5159 build_special_member_call (tree instance, tree name, tree args,
5160                            tree binfo, int flags)
5161 {
5162   tree fns;
5163   /* The type of the subobject to be constructed or destroyed.  */
5164   tree class_type;
5165
5166   gcc_assert (name == complete_ctor_identifier
5167               || name == base_ctor_identifier
5168               || name == complete_dtor_identifier
5169               || name == base_dtor_identifier
5170               || name == deleting_dtor_identifier
5171               || name == ansi_assopname (NOP_EXPR));
5172   if (TYPE_P (binfo))
5173     {
5174       /* Resolve the name.  */
5175       if (!complete_type_or_else (binfo, NULL_TREE))
5176         return error_mark_node;
5177
5178       binfo = TYPE_BINFO (binfo);
5179     }
5180
5181   gcc_assert (binfo != NULL_TREE);
5182
5183   class_type = BINFO_TYPE (binfo);
5184
5185   /* Handle the special case where INSTANCE is NULL_TREE.  */
5186   if (name == complete_ctor_identifier && !instance)
5187     {
5188       instance = build_int_cst (build_pointer_type (class_type), 0);
5189       instance = build1 (INDIRECT_REF, class_type, instance);
5190     }
5191   else
5192     {
5193       if (name == complete_dtor_identifier
5194           || name == base_dtor_identifier
5195           || name == deleting_dtor_identifier)
5196         gcc_assert (args == NULL_TREE);
5197
5198       /* Convert to the base class, if necessary.  */
5199       if (!same_type_ignoring_top_level_qualifiers_p
5200           (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5201         {
5202           if (name != ansi_assopname (NOP_EXPR))
5203             /* For constructors and destructors, either the base is
5204                non-virtual, or it is virtual but we are doing the
5205                conversion from a constructor or destructor for the
5206                complete object.  In either case, we can convert
5207                statically.  */
5208             instance = convert_to_base_statically (instance, binfo);
5209           else
5210             /* However, for assignment operators, we must convert
5211                dynamically if the base is virtual.  */
5212             instance = build_base_path (PLUS_EXPR, instance,
5213                                         binfo, /*nonnull=*/1);
5214         }
5215     }
5216
5217   gcc_assert (instance != NULL_TREE);
5218
5219   fns = lookup_fnfields (binfo, name, 1);
5220
5221   /* When making a call to a constructor or destructor for a subobject
5222      that uses virtual base classes, pass down a pointer to a VTT for
5223      the subobject.  */
5224   if ((name == base_ctor_identifier
5225        || name == base_dtor_identifier)
5226       && CLASSTYPE_VBASECLASSES (class_type))
5227     {
5228       tree vtt;
5229       tree sub_vtt;
5230
5231       /* If the current function is a complete object constructor
5232          or destructor, then we fetch the VTT directly.
5233          Otherwise, we look it up using the VTT we were given.  */
5234       vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5235       vtt = decay_conversion (vtt);
5236       vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5237                     build2 (EQ_EXPR, boolean_type_node,
5238                             current_in_charge_parm, integer_zero_node),
5239                     current_vtt_parm,
5240                     vtt);
5241       gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5242       sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5243                         BINFO_SUBVTT_INDEX (binfo));
5244
5245       args = tree_cons (NULL_TREE, sub_vtt, args);
5246     }
5247
5248   return build_new_method_call (instance, fns, args,
5249                                 TYPE_BINFO (BINFO_TYPE (binfo)),
5250                                 flags, /*fn=*/NULL);
5251 }
5252
5253 /* Return the NAME, as a C string.  The NAME indicates a function that
5254    is a member of TYPE.  *FREE_P is set to true if the caller must
5255    free the memory returned.
5256
5257    Rather than go through all of this, we should simply set the names
5258    of constructors and destructors appropriately, and dispense with
5259    ctor_identifier, dtor_identifier, etc.  */
5260
5261 static char *
5262 name_as_c_string (tree name, tree type, bool *free_p)
5263 {
5264   char *pretty_name;
5265
5266   /* Assume that we will not allocate memory.  */
5267   *free_p = false;
5268   /* Constructors and destructors are special.  */
5269   if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5270     {
5271       pretty_name
5272         = (char *) IDENTIFIER_POINTER (constructor_name (type));
5273       /* For a destructor, add the '~'.  */
5274       if (name == complete_dtor_identifier
5275           || name == base_dtor_identifier
5276           || name == deleting_dtor_identifier)
5277         {
5278           pretty_name = concat ("~", pretty_name, NULL);
5279           /* Remember that we need to free the memory allocated.  */
5280           *free_p = true;
5281         }
5282     }
5283   else if (IDENTIFIER_TYPENAME_P (name))
5284     {
5285       pretty_name = concat ("operator ",
5286                             type_as_string (TREE_TYPE (name),
5287                                             TFF_PLAIN_IDENTIFIER),
5288                             NULL);
5289       /* Remember that we need to free the memory allocated.  */
5290       *free_p = true;
5291     }
5292   else
5293     pretty_name = (char *) IDENTIFIER_POINTER (name);
5294
5295   return pretty_name;
5296 }
5297
5298 /* Build a call to "INSTANCE.FN (ARGS)".  If FN_P is non-NULL, it will
5299    be set, upon return, to the function called.  */
5300
5301 tree
5302 build_new_method_call (tree instance, tree fns, tree args,
5303                        tree conversion_path, int flags,
5304                        tree *fn_p)
5305 {
5306   struct z_candidate *candidates = 0, *cand;
5307   tree explicit_targs = NULL_TREE;
5308   tree basetype = NULL_TREE;
5309   tree access_binfo;
5310   tree optype;
5311   tree mem_args = NULL_TREE, instance_ptr;
5312   tree name;
5313   tree user_args;
5314   tree call;
5315   tree fn;
5316   tree class_type;
5317   int template_only = 0;
5318   bool any_viable_p;
5319   tree orig_instance;
5320   tree orig_fns;
5321   tree orig_args;
5322   void *p;
5323
5324   gcc_assert (instance != NULL_TREE);
5325
5326   /* We don't know what function we're going to call, yet.  */
5327   if (fn_p)
5328     *fn_p = NULL_TREE;
5329
5330   if (error_operand_p (instance)
5331       || error_operand_p (fns)
5332       || args == error_mark_node)
5333     return error_mark_node;
5334
5335   if (!BASELINK_P (fns))
5336     {
5337       error ("call to non-function %qD", fns);
5338       return error_mark_node;
5339     }
5340
5341   orig_instance = instance;
5342   orig_fns = fns;
5343   orig_args = args;
5344
5345   /* Dismantle the baselink to collect all the information we need.  */
5346   if (!conversion_path)
5347     conversion_path = BASELINK_BINFO (fns);
5348   access_binfo = BASELINK_ACCESS_BINFO (fns);
5349   optype = BASELINK_OPTYPE (fns);
5350   fns = BASELINK_FUNCTIONS (fns);
5351   if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5352     {
5353       explicit_targs = TREE_OPERAND (fns, 1);
5354       fns = TREE_OPERAND (fns, 0);
5355       template_only = 1;
5356     }
5357   gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5358               || TREE_CODE (fns) == TEMPLATE_DECL
5359               || TREE_CODE (fns) == OVERLOAD);
5360   fn = get_first_fn (fns);
5361   name = DECL_NAME (fn);
5362
5363   basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5364   gcc_assert (CLASS_TYPE_P (basetype));
5365
5366   if (processing_template_decl)
5367     {
5368       instance = build_non_dependent_expr (instance);
5369       args = build_non_dependent_args (orig_args);
5370     }
5371
5372   /* The USER_ARGS are the arguments we will display to users if an
5373      error occurs.  The USER_ARGS should not include any
5374      compiler-generated arguments.  The "this" pointer hasn't been
5375      added yet.  However, we must remove the VTT pointer if this is a
5376      call to a base-class constructor or destructor.  */
5377   user_args = args;
5378   if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5379     {
5380       /* Callers should explicitly indicate whether they want to construct
5381          the complete object or just the part without virtual bases.  */
5382       gcc_assert (name != ctor_identifier);
5383       /* Similarly for destructors.  */
5384       gcc_assert (name != dtor_identifier);
5385       /* Remove the VTT pointer, if present.  */
5386       if ((name == base_ctor_identifier || name == base_dtor_identifier)
5387           && CLASSTYPE_VBASECLASSES (basetype))
5388         user_args = TREE_CHAIN (user_args);
5389     }
5390
5391   /* Process the argument list.  */
5392   args = resolve_args (args);
5393   if (args == error_mark_node)
5394     return error_mark_node;
5395
5396   instance_ptr = build_this (instance);
5397
5398   /* It's OK to call destructors on cv-qualified objects.  Therefore,
5399      convert the INSTANCE_PTR to the unqualified type, if necessary.  */
5400   if (DECL_DESTRUCTOR_P (fn))
5401     {
5402       tree type = build_pointer_type (basetype);
5403       if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5404         instance_ptr = build_nop (type, instance_ptr);
5405       name = complete_dtor_identifier;
5406     }
5407
5408   class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5409   mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5410
5411   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
5412   p = conversion_obstack_alloc (0);
5413
5414   for (fn = fns; fn; fn = OVL_NEXT (fn))
5415     {
5416       tree t = OVL_CURRENT (fn);
5417       tree this_arglist;
5418
5419       /* We can end up here for copy-init of same or base class.  */
5420       if ((flags & LOOKUP_ONLYCONVERTING)
5421           && DECL_NONCONVERTING_P (t))
5422         continue;
5423
5424       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5425         this_arglist = mem_args;
5426       else
5427         this_arglist = args;
5428
5429       if (TREE_CODE (t) == TEMPLATE_DECL)
5430         /* A member template.  */
5431         add_template_candidate (&candidates, t,
5432                                 class_type,
5433                                 explicit_targs,
5434                                 this_arglist, optype,
5435                                 access_binfo,
5436                                 conversion_path,
5437                                 flags,
5438                                 DEDUCE_CALL);
5439       else if (! template_only)
5440         add_function_candidate (&candidates, t,
5441                                 class_type,
5442                                 this_arglist,
5443                                 access_binfo,
5444                                 conversion_path,
5445                                 flags);
5446     }
5447
5448   candidates = splice_viable (candidates, pedantic, &any_viable_p);
5449   if (!any_viable_p)
5450     {
5451       if (!COMPLETE_TYPE_P (basetype))
5452         cxx_incomplete_type_error (instance_ptr, basetype);
5453       else
5454         {
5455           char *pretty_name;
5456           bool free_p;
5457
5458           pretty_name = name_as_c_string (name, basetype, &free_p);
5459           error ("no matching function for call to %<%T::%s(%A)%#V%>",
5460                  basetype, pretty_name, user_args,
5461                  TREE_TYPE (TREE_TYPE (instance_ptr)));
5462           if (free_p)
5463             free (pretty_name);
5464         }
5465       print_z_candidates (candidates);
5466       call = error_mark_node;
5467     }
5468   else
5469     {
5470       cand = tourney (candidates);
5471       if (cand == 0)
5472         {
5473           char *pretty_name;
5474           bool free_p;
5475
5476           pretty_name = name_as_c_string (name, basetype, &free_p);
5477           error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5478                  user_args);
5479           print_z_candidates (candidates);
5480           if (free_p)
5481             free (pretty_name);
5482           call = error_mark_node;
5483         }
5484       else
5485         {
5486           fn = cand->fn;
5487
5488           if (!(flags & LOOKUP_NONVIRTUAL)
5489               && DECL_PURE_VIRTUAL_P (fn)
5490               && instance == current_class_ref
5491               && (DECL_CONSTRUCTOR_P (current_function_decl)
5492                   || DECL_DESTRUCTOR_P (current_function_decl)))
5493             /* This is not an error, it is runtime undefined
5494                behavior.  */
5495             warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
5496                       "abstract virtual %q#D called from constructor"
5497                       : "abstract virtual %q#D called from destructor"),
5498                      fn);
5499
5500           if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
5501               && is_dummy_object (instance_ptr))
5502             {
5503               error ("cannot call member function %qD without object",
5504                      fn);
5505               call = error_mark_node;
5506             }
5507           else
5508             {
5509               if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
5510                   && resolves_to_fixed_type_p (instance, 0))
5511                 flags |= LOOKUP_NONVIRTUAL;
5512               /* Now we know what function is being called.  */
5513               if (fn_p)
5514                 *fn_p = fn;
5515               /* Build the actual CALL_EXPR.  */
5516               call = build_over_call (cand, flags);
5517               /* In an expression of the form `a->f()' where `f' turns
5518                  out to be a static member function, `a' is
5519                  none-the-less evaluated.  */
5520               if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
5521                   && !is_dummy_object (instance_ptr)
5522                   && TREE_SIDE_EFFECTS (instance_ptr))
5523                 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5524                                instance_ptr, call);
5525               else if (call != error_mark_node
5526                        && DECL_DESTRUCTOR_P (cand->fn)
5527                        && !VOID_TYPE_P (TREE_TYPE (call)))
5528                 /* An explicit call of the form "x->~X()" has type
5529                    "void".  However, on platforms where destructors
5530                    return "this" (i.e., those where
5531                    targetm.cxx.cdtor_returns_this is true), such calls
5532                    will appear to have a return value of pointer type
5533                    to the low-level call machinery.  We do not want to
5534                    change the low-level machinery, since we want to be
5535                    able to optimize "delete f()" on such platforms as
5536                    "operator delete(~X(f()))" (rather than generating
5537                    "t = f(), ~X(t), operator delete (t)").  */
5538                 call = build_nop (void_type_node, call);
5539             }
5540         }
5541     }
5542
5543   if (processing_template_decl && call != error_mark_node)
5544     call = (build_min_non_dep
5545             (CALL_EXPR, call,
5546              build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5547              orig_args, NULL_TREE));
5548
5549  /* Free all the conversions we allocated.  */
5550   obstack_free (&conversion_obstack, p);
5551
5552   return call;
5553 }
5554
5555 /* Returns true iff standard conversion sequence ICS1 is a proper
5556    subsequence of ICS2.  */
5557
5558 static bool
5559 is_subseq (conversion *ics1, conversion *ics2)
5560 {
5561   /* We can assume that a conversion of the same code
5562      between the same types indicates a subsequence since we only get
5563      here if the types we are converting from are the same.  */
5564
5565   while (ics1->kind == ck_rvalue
5566          || ics1->kind == ck_lvalue)
5567     ics1 = ics1->u.next;
5568
5569   while (1)
5570     {
5571       while (ics2->kind == ck_rvalue
5572              || ics2->kind == ck_lvalue)
5573         ics2 = ics2->u.next;
5574
5575       if (ics2->kind == ck_user
5576           || ics2->kind == ck_ambig
5577           || ics2->kind == ck_identity)
5578         /* At this point, ICS1 cannot be a proper subsequence of
5579            ICS2.  We can get a USER_CONV when we are comparing the
5580            second standard conversion sequence of two user conversion
5581            sequences.  */
5582         return false;
5583
5584       ics2 = ics2->u.next;
5585
5586       if (ics2->kind == ics1->kind
5587           && same_type_p (ics2->type, ics1->type)
5588           && same_type_p (ics2->u.next->type,
5589                           ics1->u.next->type))
5590         return true;
5591     }
5592 }
5593
5594 /* Returns nonzero iff DERIVED is derived from BASE.  The inputs may
5595    be any _TYPE nodes.  */
5596
5597 bool
5598 is_properly_derived_from (tree derived, tree base)
5599 {
5600   if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5601       || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5602     return false;
5603
5604   /* We only allow proper derivation here.  The DERIVED_FROM_P macro
5605      considers every class derived from itself.  */
5606   return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5607           && DERIVED_FROM_P (base, derived));
5608 }
5609
5610 /* We build the ICS for an implicit object parameter as a pointer
5611    conversion sequence.  However, such a sequence should be compared
5612    as if it were a reference conversion sequence.  If ICS is the
5613    implicit conversion sequence for an implicit object parameter,
5614    modify it accordingly.  */
5615
5616 static void
5617 maybe_handle_implicit_object (conversion **ics)
5618 {
5619   if ((*ics)->this_p)
5620     {
5621       /* [over.match.funcs]
5622
5623          For non-static member functions, the type of the
5624          implicit object parameter is "reference to cv X"
5625          where X is the class of which the function is a
5626          member and cv is the cv-qualification on the member
5627          function declaration.  */
5628       conversion *t = *ics;
5629       tree reference_type;
5630
5631       /* The `this' parameter is a pointer to a class type.  Make the
5632          implicit conversion talk about a reference to that same class
5633          type.  */
5634       reference_type = TREE_TYPE (t->type);
5635       reference_type = build_reference_type (reference_type);
5636
5637       if (t->kind == ck_qual)
5638         t = t->u.next;
5639       if (t->kind == ck_ptr)
5640         t = t->u.next;
5641       t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5642       t = direct_reference_binding (reference_type, t);
5643       *ics = t;
5644     }
5645 }
5646
5647 /* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5648    and return the type to which the reference refers.  Otherwise,
5649    leave *ICS unchanged and return NULL_TREE.  */
5650
5651 static tree
5652 maybe_handle_ref_bind (conversion **ics)
5653 {
5654   if ((*ics)->kind == ck_ref_bind)
5655     {
5656       conversion *old_ics = *ics;
5657       tree type = TREE_TYPE (old_ics->type);
5658       *ics = old_ics->u.next;
5659       (*ics)->user_conv_p = old_ics->user_conv_p;
5660       (*ics)->bad_p = old_ics->bad_p;
5661       return type;
5662     }
5663
5664   return NULL_TREE;
5665 }
5666
5667 /* Compare two implicit conversion sequences according to the rules set out in
5668    [over.ics.rank].  Return values:
5669
5670       1: ics1 is better than ics2
5671      -1: ics2 is better than ics1
5672       0: ics1 and ics2 are indistinguishable */
5673
5674 static int
5675 compare_ics (conversion *ics1, conversion *ics2)
5676 {
5677   tree from_type1;
5678   tree from_type2;
5679   tree to_type1;
5680   tree to_type2;
5681   tree deref_from_type1 = NULL_TREE;
5682   tree deref_from_type2 = NULL_TREE;
5683   tree deref_to_type1 = NULL_TREE;
5684   tree deref_to_type2 = NULL_TREE;
5685   conversion_rank rank1, rank2;
5686
5687   /* REF_BINDING is nonzero if the result of the conversion sequence
5688      is a reference type.   In that case TARGET_TYPE is the
5689      type referred to by the reference.  */
5690   tree target_type1;
5691   tree target_type2;
5692
5693   /* Handle implicit object parameters.  */
5694   maybe_handle_implicit_object (&ics1);
5695   maybe_handle_implicit_object (&ics2);
5696
5697   /* Handle reference parameters.  */
5698   target_type1 = maybe_handle_ref_bind (&ics1);
5699   target_type2 = maybe_handle_ref_bind (&ics2);
5700
5701   /* [over.ics.rank]
5702
5703      When  comparing  the  basic forms of implicit conversion sequences (as
5704      defined in _over.best.ics_)
5705
5706      --a standard conversion sequence (_over.ics.scs_) is a better
5707        conversion sequence than a user-defined conversion sequence
5708        or an ellipsis conversion sequence, and
5709
5710      --a user-defined conversion sequence (_over.ics.user_) is a
5711        better conversion sequence than an ellipsis conversion sequence
5712        (_over.ics.ellipsis_).  */
5713   rank1 = CONVERSION_RANK (ics1);
5714   rank2 = CONVERSION_RANK (ics2);
5715
5716   if (rank1 > rank2)
5717     return -1;
5718   else if (rank1 < rank2)
5719     return 1;
5720
5721   if (rank1 == cr_bad)
5722     {
5723       /* XXX Isn't this an extension? */
5724       /* Both ICS are bad.  We try to make a decision based on what
5725          would have happened if they'd been good.  */
5726       if (ics1->user_conv_p > ics2->user_conv_p
5727           || ics1->rank  > ics2->rank)
5728         return -1;
5729       else if (ics1->user_conv_p < ics2->user_conv_p
5730                || ics1->rank < ics2->rank)
5731         return 1;
5732
5733       /* We couldn't make up our minds; try to figure it out below.  */
5734     }
5735
5736   if (ics1->ellipsis_p)
5737     /* Both conversions are ellipsis conversions.  */
5738     return 0;
5739
5740   /* User-defined  conversion sequence U1 is a better conversion sequence
5741      than another user-defined conversion sequence U2 if they contain the
5742      same user-defined conversion operator or constructor and if the sec-
5743      ond standard conversion sequence of U1 is  better  than  the  second
5744      standard conversion sequence of U2.  */
5745
5746   if (ics1->user_conv_p)
5747     {
5748       conversion *t1;
5749       conversion *t2;
5750
5751       for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5752         if (t1->kind == ck_ambig)
5753           return 0;
5754       for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5755         if (t2->kind == ck_ambig)
5756           return 0;
5757
5758       if (t1->cand->fn != t2->cand->fn)
5759         return 0;
5760
5761       /* We can just fall through here, after setting up
5762          FROM_TYPE1 and FROM_TYPE2.  */
5763       from_type1 = t1->type;
5764       from_type2 = t2->type;
5765     }
5766   else
5767     {
5768       conversion *t1;
5769       conversion *t2;
5770
5771       /* We're dealing with two standard conversion sequences.
5772
5773          [over.ics.rank]
5774
5775          Standard conversion sequence S1 is a better conversion
5776          sequence than standard conversion sequence S2 if
5777
5778          --S1 is a proper subsequence of S2 (comparing the conversion
5779            sequences in the canonical form defined by _over.ics.scs_,
5780            excluding any Lvalue Transformation; the identity
5781            conversion sequence is considered to be a subsequence of
5782            any non-identity conversion sequence */
5783
5784       t1 = ics1;
5785       while (t1->kind != ck_identity)
5786         t1 = t1->u.next;
5787       from_type1 = t1->type;
5788
5789       t2 = ics2;
5790       while (t2->kind != ck_identity)
5791         t2 = t2->u.next;
5792       from_type2 = t2->type;
5793     }
5794
5795   if (same_type_p (from_type1, from_type2))
5796     {
5797       if (is_subseq (ics1, ics2))
5798         return 1;
5799       if (is_subseq (ics2, ics1))
5800         return -1;
5801     }
5802   /* Otherwise, one sequence cannot be a subsequence of the other; they
5803      don't start with the same type.  This can happen when comparing the
5804      second standard conversion sequence in two user-defined conversion
5805      sequences.  */
5806
5807   /* [over.ics.rank]
5808
5809      Or, if not that,
5810
5811      --the rank of S1 is better than the rank of S2 (by the rules
5812        defined below):
5813
5814     Standard conversion sequences are ordered by their ranks: an Exact
5815     Match is a better conversion than a Promotion, which is a better
5816     conversion than a Conversion.
5817
5818     Two conversion sequences with the same rank are indistinguishable
5819     unless one of the following rules applies:
5820
5821     --A conversion that is not a conversion of a pointer, or pointer
5822       to member, to bool is better than another conversion that is such
5823       a conversion.
5824
5825     The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5826     so that we do not have to check it explicitly.  */
5827   if (ics1->rank < ics2->rank)
5828     return 1;
5829   else if (ics2->rank < ics1->rank)
5830     return -1;
5831
5832   to_type1 = ics1->type;
5833   to_type2 = ics2->type;
5834
5835   if (TYPE_PTR_P (from_type1)
5836       && TYPE_PTR_P (from_type2)
5837       && TYPE_PTR_P (to_type1)
5838       && TYPE_PTR_P (to_type2))
5839     {
5840       deref_from_type1 = TREE_TYPE (from_type1);
5841       deref_from_type2 = TREE_TYPE (from_type2);
5842       deref_to_type1 = TREE_TYPE (to_type1);
5843       deref_to_type2 = TREE_TYPE (to_type2);
5844     }
5845   /* The rules for pointers to members A::* are just like the rules
5846      for pointers A*, except opposite: if B is derived from A then
5847      A::* converts to B::*, not vice versa.  For that reason, we
5848      switch the from_ and to_ variables here.  */
5849   else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5850             && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5851            || (TYPE_PTRMEMFUNC_P (from_type1)
5852                && TYPE_PTRMEMFUNC_P (from_type2)
5853                && TYPE_PTRMEMFUNC_P (to_type1)
5854                && TYPE_PTRMEMFUNC_P (to_type2)))
5855     {
5856       deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5857       deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5858       deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5859       deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5860     }
5861
5862   if (deref_from_type1 != NULL_TREE
5863       && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5864       && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5865     {
5866       /* This was one of the pointer or pointer-like conversions.
5867
5868          [over.ics.rank]
5869
5870          --If class B is derived directly or indirectly from class A,
5871            conversion of B* to A* is better than conversion of B* to
5872            void*, and conversion of A* to void* is better than
5873            conversion of B* to void*.  */
5874       if (TREE_CODE (deref_to_type1) == VOID_TYPE
5875           && TREE_CODE (deref_to_type2) == VOID_TYPE)
5876         {
5877           if (is_properly_derived_from (deref_from_type1,
5878                                         deref_from_type2))
5879             return -1;
5880           else if (is_properly_derived_from (deref_from_type2,
5881                                              deref_from_type1))
5882             return 1;
5883         }
5884       else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5885                || TREE_CODE (deref_to_type2) == VOID_TYPE)
5886         {
5887           if (same_type_p (deref_from_type1, deref_from_type2))
5888             {
5889               if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5890                 {
5891                   if (is_properly_derived_from (deref_from_type1,
5892                                                 deref_to_type1))
5893                     return 1;
5894                 }
5895               /* We know that DEREF_TO_TYPE1 is `void' here.  */
5896               else if (is_properly_derived_from (deref_from_type1,
5897                                                  deref_to_type2))
5898                 return -1;
5899             }
5900         }
5901       else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5902                && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5903         {
5904           /* [over.ics.rank]
5905
5906              --If class B is derived directly or indirectly from class A
5907                and class C is derived directly or indirectly from B,
5908
5909              --conversion of C* to B* is better than conversion of C* to
5910                A*,
5911
5912              --conversion of B* to A* is better than conversion of C* to
5913                A*  */
5914           if (same_type_p (deref_from_type1, deref_from_type2))
5915             {
5916               if (is_properly_derived_from (deref_to_type1,
5917                                             deref_to_type2))
5918                 return 1;
5919               else if (is_properly_derived_from (deref_to_type2,
5920                                                  deref_to_type1))
5921                 return -1;
5922             }
5923           else if (same_type_p (deref_to_type1, deref_to_type2))
5924             {
5925               if (is_properly_derived_from (deref_from_type2,
5926                                             deref_from_type1))
5927                 return 1;
5928               else if (is_properly_derived_from (deref_from_type1,
5929                                                  deref_from_type2))
5930                 return -1;
5931             }
5932         }
5933     }
5934   else if (CLASS_TYPE_P (non_reference (from_type1))
5935            && same_type_p (from_type1, from_type2))
5936     {
5937       tree from = non_reference (from_type1);
5938
5939       /* [over.ics.rank]
5940
5941          --binding of an expression of type C to a reference of type
5942            B& is better than binding an expression of type C to a
5943            reference of type A&
5944
5945          --conversion of C to B is better than conversion of C to A,  */
5946       if (is_properly_derived_from (from, to_type1)
5947           && is_properly_derived_from (from, to_type2))
5948         {
5949           if (is_properly_derived_from (to_type1, to_type2))
5950             return 1;
5951           else if (is_properly_derived_from (to_type2, to_type1))
5952             return -1;
5953         }
5954     }
5955   else if (CLASS_TYPE_P (non_reference (to_type1))
5956            && same_type_p (to_type1, to_type2))
5957     {
5958       tree to = non_reference (to_type1);
5959
5960       /* [over.ics.rank]
5961
5962          --binding of an expression of type B to a reference of type
5963            A& is better than binding an expression of type C to a
5964            reference of type A&,
5965
5966          --conversion of B to A is better than conversion of C to A  */
5967       if (is_properly_derived_from (from_type1, to)
5968           && is_properly_derived_from (from_type2, to))
5969         {
5970           if (is_properly_derived_from (from_type2, from_type1))
5971             return 1;
5972           else if (is_properly_derived_from (from_type1, from_type2))
5973             return -1;
5974         }
5975     }
5976
5977   /* [over.ics.rank]
5978
5979      --S1 and S2 differ only in their qualification conversion and  yield
5980        similar  types  T1 and T2 (_conv.qual_), respectively, and the cv-
5981        qualification signature of type T1 is a proper subset of  the  cv-
5982        qualification signature of type T2  */
5983   if (ics1->kind == ck_qual
5984       && ics2->kind == ck_qual
5985       && same_type_p (from_type1, from_type2))
5986     return comp_cv_qual_signature (to_type1, to_type2);
5987
5988   /* [over.ics.rank]
5989
5990      --S1 and S2 are reference bindings (_dcl.init.ref_), and the
5991      types to which the references refer are the same type except for
5992      top-level cv-qualifiers, and the type to which the reference
5993      initialized by S2 refers is more cv-qualified than the type to
5994      which the reference initialized by S1 refers */
5995
5996   if (target_type1 && target_type2
5997       && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
5998     return comp_cv_qualification (target_type2, target_type1);
5999
6000   /* Neither conversion sequence is better than the other.  */
6001   return 0;
6002 }
6003
6004 /* The source type for this standard conversion sequence.  */
6005
6006 static tree
6007 source_type (conversion *t)
6008 {
6009   for (;; t = t->u.next)
6010     {
6011       if (t->kind == ck_user
6012           || t->kind == ck_ambig
6013           || t->kind == ck_identity)
6014         return t->type;
6015     }
6016   gcc_unreachable ();
6017 }
6018
6019 /* Note a warning about preferring WINNER to LOSER.  We do this by storing
6020    a pointer to LOSER and re-running joust to produce the warning if WINNER
6021    is actually used.  */
6022
6023 static void
6024 add_warning (struct z_candidate *winner, struct z_candidate *loser)
6025 {
6026   candidate_warning *cw = (candidate_warning *)
6027     conversion_obstack_alloc (sizeof (candidate_warning));
6028   cw->loser = loser;
6029   cw->next = winner->warnings;
6030   winner->warnings = cw;
6031 }
6032
6033 /* Compare two candidates for overloading as described in
6034    [over.match.best].  Return values:
6035
6036       1: cand1 is better than cand2
6037      -1: cand2 is better than cand1
6038       0: cand1 and cand2 are indistinguishable */
6039
6040 static int
6041 joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
6042 {
6043   int winner = 0;
6044   int off1 = 0, off2 = 0;
6045   size_t i;
6046   size_t len;
6047
6048   /* Candidates that involve bad conversions are always worse than those
6049      that don't.  */
6050   if (cand1->viable > cand2->viable)
6051     return 1;
6052   if (cand1->viable < cand2->viable)
6053     return -1;
6054
6055   /* If we have two pseudo-candidates for conversions to the same type,
6056      or two candidates for the same function, arbitrarily pick one.  */
6057   if (cand1->fn == cand2->fn
6058       && (IS_TYPE_OR_DECL_P (cand1->fn)))
6059     return 1;
6060
6061   /* a viable function F1
6062      is defined to be a better function than another viable function F2  if
6063      for  all arguments i, ICSi(F1) is not a worse conversion sequence than
6064      ICSi(F2), and then */
6065
6066   /* for some argument j, ICSj(F1) is a better conversion  sequence  than
6067      ICSj(F2) */
6068
6069   /* For comparing static and non-static member functions, we ignore
6070      the implicit object parameter of the non-static function.  The
6071      standard says to pretend that the static function has an object
6072      parm, but that won't work with operator overloading.  */
6073   len = cand1->num_convs;
6074   if (len != cand2->num_convs)
6075     {
6076       int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
6077       int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
6078
6079       gcc_assert (static_1 != static_2);
6080
6081       if (static_1)
6082         off2 = 1;
6083       else
6084         {
6085           off1 = 1;
6086           --len;
6087         }
6088     }
6089
6090   for (i = 0; i < len; ++i)
6091     {
6092       conversion *t1 = cand1->convs[i + off1];
6093       conversion *t2 = cand2->convs[i + off2];
6094       int comp = compare_ics (t1, t2);
6095
6096       if (comp != 0)
6097         {
6098           if (warn_sign_promo
6099               && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
6100                   == cr_std + cr_promotion)
6101               && t1->kind == ck_std
6102               && t2->kind == ck_std
6103               && TREE_CODE (t1->type) == INTEGER_TYPE
6104               && TREE_CODE (t2->type) == INTEGER_TYPE
6105               && (TYPE_PRECISION (t1->type)
6106                   == TYPE_PRECISION (t2->type))
6107               && (TYPE_UNSIGNED (t1->u.next->type)
6108                   || (TREE_CODE (t1->u.next->type)
6109                       == ENUMERAL_TYPE)))
6110             {
6111               tree type = t1->u.next->type;
6112               tree type1, type2;
6113               struct z_candidate *w, *l;
6114               if (comp > 0)
6115                 type1 = t1->type, type2 = t2->type,
6116                   w = cand1, l = cand2;
6117               else
6118                 type1 = t2->type, type2 = t1->type,
6119                   w = cand2, l = cand1;
6120
6121               if (warn)
6122                 {
6123                   warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
6124                            type, type1, type2);
6125                   warning (OPT_Wsign_promo, "  in call to %qD", w->fn);
6126                 }
6127               else
6128                 add_warning (w, l);
6129             }
6130
6131           if (winner && comp != winner)
6132             {
6133               winner = 0;
6134               goto tweak;
6135             }
6136           winner = comp;
6137         }
6138     }
6139
6140   /* warn about confusing overload resolution for user-defined conversions,
6141      either between a constructor and a conversion op, or between two
6142      conversion ops.  */
6143   if (winner && warn_conversion && cand1->second_conv
6144       && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6145       && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6146     {
6147       struct z_candidate *w, *l;
6148       bool give_warning = false;
6149
6150       if (winner == 1)
6151         w = cand1, l = cand2;
6152       else
6153         w = cand2, l = cand1;
6154
6155       /* We don't want to complain about `X::operator T1 ()'
6156          beating `X::operator T2 () const', when T2 is a no less
6157          cv-qualified version of T1.  */
6158       if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6159           && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6160         {
6161           tree t = TREE_TYPE (TREE_TYPE (l->fn));
6162           tree f = TREE_TYPE (TREE_TYPE (w->fn));
6163
6164           if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6165             {
6166               t = TREE_TYPE (t);
6167               f = TREE_TYPE (f);
6168             }
6169           if (!comp_ptr_ttypes (t, f))
6170             give_warning = true;
6171         }
6172       else
6173         give_warning = true;
6174
6175       if (!give_warning)
6176         /*NOP*/;
6177       else if (warn)
6178         {
6179           tree source = source_type (w->convs[0]);
6180           if (! DECL_CONSTRUCTOR_P (w->fn))
6181             source = TREE_TYPE (source);
6182           warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn);
6183           warning (OPT_Wconversion, "  for conversion from %qT to %qT",
6184                    source, w->second_conv->type);
6185           inform ("  because conversion sequence for the argument is better");
6186         }
6187       else
6188         add_warning (w, l);
6189     }
6190
6191   if (winner)
6192     return winner;
6193
6194   /* or, if not that,
6195      F1 is a non-template function and F2 is a template function
6196      specialization.  */
6197
6198   if (!cand1->template_decl && cand2->template_decl)
6199     return 1;
6200   else if (cand1->template_decl && !cand2->template_decl)
6201     return -1;
6202
6203   /* or, if not that,
6204      F1 and F2 are template functions and the function template for F1 is
6205      more specialized than the template for F2 according to the partial
6206      ordering rules.  */
6207
6208   if (cand1->template_decl && cand2->template_decl)
6209     {
6210       winner = more_specialized_fn
6211         (TI_TEMPLATE (cand1->template_decl),
6212          TI_TEMPLATE (cand2->template_decl),
6213          /* [temp.func.order]: The presence of unused ellipsis and default
6214             arguments has no effect on the partial ordering of function
6215             templates.   add_function_candidate() will not have
6216             counted the "this" argument for constructors.  */
6217          cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
6218       if (winner)
6219         return winner;
6220     }
6221
6222   /* or, if not that,
6223      the  context  is  an  initialization by user-defined conversion (see
6224      _dcl.init_  and  _over.match.user_)  and  the  standard   conversion
6225      sequence  from  the return type of F1 to the destination type (i.e.,
6226      the type of the entity being initialized)  is  a  better  conversion
6227      sequence  than the standard conversion sequence from the return type
6228      of F2 to the destination type.  */
6229
6230   if (cand1->second_conv)
6231     {
6232       winner = compare_ics (cand1->second_conv, cand2->second_conv);
6233       if (winner)
6234         return winner;
6235     }
6236
6237   /* Check whether we can discard a builtin candidate, either because we
6238      have two identical ones or matching builtin and non-builtin candidates.
6239
6240      (Pedantically in the latter case the builtin which matched the user
6241      function should not be added to the overload set, but we spot it here.
6242
6243      [over.match.oper]
6244      ... the builtin candidates include ...
6245      - do not have the same parameter type list as any non-template
6246        non-member candidate.  */
6247
6248   if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6249       || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6250     {
6251       for (i = 0; i < len; ++i)
6252         if (!same_type_p (cand1->convs[i]->type,
6253                           cand2->convs[i]->type))
6254           break;
6255       if (i == cand1->num_convs)
6256         {
6257           if (cand1->fn == cand2->fn)
6258             /* Two built-in candidates; arbitrarily pick one.  */
6259             return 1;
6260           else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6261             /* cand1 is built-in; prefer cand2.  */
6262             return -1;
6263           else
6264             /* cand2 is built-in; prefer cand1.  */
6265             return 1;
6266         }
6267     }
6268
6269   /* If the two functions are the same (this can happen with declarations
6270      in multiple scopes and arg-dependent lookup), arbitrarily choose one.  */
6271   if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6272       && equal_functions (cand1->fn, cand2->fn))
6273     return 1;
6274
6275 tweak:
6276
6277   /* Extension: If the worst conversion for one candidate is worse than the
6278      worst conversion for the other, take the first.  */
6279   if (!pedantic)
6280     {
6281       conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6282       struct z_candidate *w = 0, *l = 0;
6283
6284       for (i = 0; i < len; ++i)
6285         {
6286           if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6287             rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6288           if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6289             rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6290         }
6291       if (rank1 < rank2)
6292         winner = 1, w = cand1, l = cand2;
6293       if (rank1 > rank2)
6294         winner = -1, w = cand2, l = cand1;
6295       if (winner)
6296         {
6297           if (warn)
6298             {
6299               pedwarn ("\
6300 ISO C++ says that these are ambiguous, even \
6301 though the worst conversion for the first is better than \
6302 the worst conversion for the second:");
6303               print_z_candidate (_("candidate 1:"), w);
6304               print_z_candidate (_("candidate 2:"), l);
6305             }
6306           else
6307             add_warning (w, l);
6308           return winner;
6309         }
6310     }
6311
6312   gcc_assert (!winner);
6313   return 0;
6314 }
6315
6316 /* Given a list of candidates for overloading, find the best one, if any.
6317    This algorithm has a worst case of O(2n) (winner is last), and a best
6318    case of O(n/2) (totally ambiguous); much better than a sorting
6319    algorithm.  */
6320
6321 static struct z_candidate *
6322 tourney (struct z_candidate *candidates)
6323 {
6324   struct z_candidate *champ = candidates, *challenger;
6325   int fate;
6326   int champ_compared_to_predecessor = 0;
6327
6328   /* Walk through the list once, comparing each current champ to the next
6329      candidate, knocking out a candidate or two with each comparison.  */
6330
6331   for (challenger = champ->next; challenger; )
6332     {
6333       fate = joust (champ, challenger, 0);
6334       if (fate == 1)
6335         challenger = challenger->next;
6336       else
6337         {
6338           if (fate == 0)
6339             {
6340               champ = challenger->next;
6341               if (champ == 0)
6342                 return NULL;
6343               champ_compared_to_predecessor = 0;
6344             }
6345           else
6346             {
6347               champ = challenger;
6348               champ_compared_to_predecessor = 1;
6349             }
6350
6351           challenger = champ->next;
6352         }
6353     }
6354
6355   /* Make sure the champ is better than all the candidates it hasn't yet
6356      been compared to.  */
6357
6358   for (challenger = candidates;
6359        challenger != champ
6360          && !(champ_compared_to_predecessor && challenger->next == champ);
6361        challenger = challenger->next)
6362     {
6363       fate = joust (champ, challenger, 0);
6364       if (fate != 1)
6365         return NULL;
6366     }
6367
6368   return champ;
6369 }
6370
6371 /* Returns nonzero if things of type FROM can be converted to TO.  */
6372
6373 bool
6374 can_convert (tree to, tree from)
6375 {
6376   return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL);
6377 }
6378
6379 /* Returns nonzero if ARG (of type FROM) can be converted to TO.  */
6380
6381 bool
6382 can_convert_arg (tree to, tree from, tree arg, int flags)
6383 {
6384   conversion *t;
6385   void *p;
6386   bool ok_p;
6387
6388   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
6389   p = conversion_obstack_alloc (0);
6390
6391   t  = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6392                             flags);
6393   ok_p = (t && !t->bad_p);
6394
6395   /* Free all the conversions we allocated.  */
6396   obstack_free (&conversion_obstack, p);
6397
6398   return ok_p;
6399 }
6400
6401 /* Like can_convert_arg, but allows dubious conversions as well.  */
6402
6403 bool
6404 can_convert_arg_bad (tree to, tree from, tree arg)
6405 {
6406   conversion *t;
6407   void *p;
6408
6409   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
6410   p = conversion_obstack_alloc (0);
6411   /* Try to perform the conversion.  */
6412   t  = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6413                             LOOKUP_NORMAL);
6414   /* Free all the conversions we allocated.  */
6415   obstack_free (&conversion_obstack, p);
6416
6417   return t != NULL;
6418 }
6419
6420 /* Convert EXPR to TYPE.  Return the converted expression.
6421
6422    Note that we allow bad conversions here because by the time we get to
6423    this point we are committed to doing the conversion.  If we end up
6424    doing a bad conversion, convert_like will complain.  */
6425
6426 tree
6427 perform_implicit_conversion (tree type, tree expr)
6428 {
6429   conversion *conv;
6430   void *p;
6431
6432   if (error_operand_p (expr))
6433     return error_mark_node;
6434
6435   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
6436   p = conversion_obstack_alloc (0);
6437
6438   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6439                               /*c_cast_p=*/false,
6440                               LOOKUP_NORMAL);
6441   if (!conv)
6442     {
6443       error ("could not convert %qE to %qT", expr, type);
6444       expr = error_mark_node;
6445     }
6446   else if (processing_template_decl)
6447     {
6448       /* In a template, we are only concerned about determining the
6449          type of non-dependent expressions, so we do not have to
6450          perform the actual conversion.  */
6451       if (TREE_TYPE (expr) != type)
6452         expr = build_nop (type, expr);
6453     }
6454   else
6455     expr = convert_like (conv, expr);
6456
6457   /* Free all the conversions we allocated.  */
6458   obstack_free (&conversion_obstack, p);
6459
6460   return expr;
6461 }
6462
6463 /* Convert EXPR to TYPE (as a direct-initialization) if that is
6464    permitted.  If the conversion is valid, the converted expression is
6465    returned.  Otherwise, NULL_TREE is returned, except in the case
6466    that TYPE is a class type; in that case, an error is issued.  If
6467    C_CAST_P is true, then this direction initialization is taking
6468    place as part of a static_cast being attempted as part of a C-style
6469    cast.  */
6470
6471 tree
6472 perform_direct_initialization_if_possible (tree type,
6473                                            tree expr,
6474                                            bool c_cast_p)
6475 {
6476   conversion *conv;
6477   void *p;
6478
6479   if (type == error_mark_node || error_operand_p (expr))
6480     return error_mark_node;
6481   /* [dcl.init]
6482
6483      If the destination type is a (possibly cv-qualified) class type:
6484
6485      -- If the initialization is direct-initialization ...,
6486      constructors are considered. ... If no constructor applies, or
6487      the overload resolution is ambiguous, the initialization is
6488      ill-formed.  */
6489   if (CLASS_TYPE_P (type))
6490     {
6491       expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6492                                         build_tree_list (NULL_TREE, expr),
6493                                         type, LOOKUP_NORMAL);
6494       return build_cplus_new (type, expr);
6495     }
6496
6497   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
6498   p = conversion_obstack_alloc (0);
6499
6500   conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6501                               c_cast_p,
6502                               LOOKUP_NORMAL);
6503   if (!conv || conv->bad_p)
6504     expr = NULL_TREE;
6505   else
6506     expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6507                               /*issue_conversion_warnings=*/false,
6508                               c_cast_p);
6509
6510   /* Free all the conversions we allocated.  */
6511   obstack_free (&conversion_obstack, p);
6512
6513   return expr;
6514 }
6515
6516 /* DECL is a VAR_DECL whose type is a REFERENCE_TYPE.  The reference
6517    is being bound to a temporary.  Create and return a new VAR_DECL
6518    with the indicated TYPE; this variable will store the value to
6519    which the reference is bound.  */
6520
6521 tree
6522 make_temporary_var_for_ref_to_temp (tree decl, tree type)
6523 {
6524   tree var;
6525
6526   /* Create the variable.  */
6527   var = create_temporary_var (type);
6528
6529   /* Register the variable.  */
6530   if (TREE_STATIC (decl))
6531     {
6532       /* Namespace-scope or local static; give it a mangled name.  */
6533       tree name;
6534
6535       TREE_STATIC (var) = 1;
6536       name = mangle_ref_init_variable (decl);
6537       DECL_NAME (var) = name;
6538       SET_DECL_ASSEMBLER_NAME (var, name);
6539       var = pushdecl_top_level (var);
6540     }
6541   else
6542     /* Create a new cleanup level if necessary.  */
6543     maybe_push_cleanup_level (type);
6544
6545   return var;
6546 }
6547
6548 /* Convert EXPR to the indicated reference TYPE, in a way suitable for
6549    initializing a variable of that TYPE.  If DECL is non-NULL, it is
6550    the VAR_DECL being initialized with the EXPR.  (In that case, the
6551    type of DECL will be TYPE.)  If DECL is non-NULL, then CLEANUP must
6552    also be non-NULL, and with *CLEANUP initialized to NULL.  Upon
6553    return, if *CLEANUP is no longer NULL, it will be an expression
6554    that should be pushed as a cleanup after the returned expression
6555    is used to initialize DECL.
6556
6557    Return the converted expression.  */
6558
6559 tree
6560 initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6561 {
6562   conversion *conv;
6563   void *p;
6564
6565   if (type == error_mark_node || error_operand_p (expr))
6566     return error_mark_node;
6567
6568   /* Get the high-water mark for the CONVERSION_OBSTACK.  */
6569   p = conversion_obstack_alloc (0);
6570
6571   conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
6572                             LOOKUP_NORMAL);
6573   if (!conv || conv->bad_p)
6574     {
6575       if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6576           && !real_lvalue_p (expr))
6577         error ("invalid initialization of non-const reference of "
6578                "type %qT from a temporary of type %qT",
6579                type, TREE_TYPE (expr));
6580       else
6581         error ("invalid initialization of reference of type "
6582                "%qT from expression of type %qT", type,
6583                TREE_TYPE (expr));
6584       return error_mark_node;
6585     }
6586
6587   /* If DECL is non-NULL, then this special rule applies:
6588
6589        [class.temporary]
6590
6591        The temporary to which the reference is bound or the temporary
6592        that is the complete object to which the reference is bound
6593        persists for the lifetime of the reference.
6594
6595        The temporaries created during the evaluation of the expression
6596        initializing the reference, except the temporary to which the
6597        reference is bound, are destroyed at the end of the
6598        full-expression in which they are created.
6599
6600      In that case, we store the converted expression into a new
6601      VAR_DECL in a new scope.
6602
6603      However, we want to be careful not to create temporaries when
6604      they are not required.  For example, given:
6605
6606        struct B {};
6607        struct D : public B {};
6608        D f();
6609        const B& b = f();
6610
6611      there is no need to copy the return value from "f"; we can just
6612      extend its lifetime.  Similarly, given:
6613
6614        struct S {};
6615        struct T { operator S(); };
6616        T t;
6617        const S& s = t;
6618
6619     we can extend the lifetime of the return value of the conversion
6620     operator.  */
6621   gcc_assert (conv->kind == ck_ref_bind);
6622   if (decl)
6623     {
6624       tree var;
6625       tree base_conv_type;
6626
6627       /* Skip over the REF_BIND.  */
6628       conv = conv->u.next;
6629       /* If the next conversion is a BASE_CONV, skip that too -- but
6630          remember that the conversion was required.  */
6631       if (conv->kind == ck_base)
6632         {
6633           if (conv->check_copy_constructor_p)
6634             check_constructor_callable (TREE_TYPE (expr), expr);
6635           base_conv_type = conv->type;
6636           conv = conv->u.next;
6637         }
6638       else
6639         base_conv_type = NULL_TREE;
6640       /* Perform the remainder of the conversion.  */
6641       expr = convert_like_real (conv, expr,
6642                                 /*fn=*/NULL_TREE, /*argnum=*/0,
6643                                 /*inner=*/-1,
6644                                 /*issue_conversion_warnings=*/true,
6645                                 /*c_cast_p=*/false);
6646       if (error_operand_p (expr))
6647         expr = error_mark_node;
6648       else
6649         {
6650           if (!real_lvalue_p (expr))
6651             {
6652               tree init;
6653               tree type;
6654
6655               /* Create the temporary variable.  */
6656               type = TREE_TYPE (expr);
6657               var = make_temporary_var_for_ref_to_temp (decl, type);
6658               layout_decl (var, 0);
6659               /* If the rvalue is the result of a function call it will be
6660                  a TARGET_EXPR.  If it is some other construct (such as a
6661                  member access expression where the underlying object is
6662                  itself the result of a function call), turn it into a
6663                  TARGET_EXPR here.  It is important that EXPR be a
6664                  TARGET_EXPR below since otherwise the INIT_EXPR will
6665                  attempt to make a bitwise copy of EXPR to initialize
6666                  VAR.  */
6667               if (TREE_CODE (expr) != TARGET_EXPR)
6668                 expr = get_target_expr (expr);
6669               /* Create the INIT_EXPR that will initialize the temporary
6670                  variable.  */
6671               init = build2 (INIT_EXPR, type, var, expr);
6672               if (at_function_scope_p ())
6673                 {
6674                   add_decl_expr (var);
6675                   *cleanup = cxx_maybe_build_cleanup (var);
6676
6677                   /* We must be careful to destroy the temporary only
6678                      after its initialization has taken place.  If the
6679                      initialization throws an exception, then the
6680                      destructor should not be run.  We cannot simply
6681                      transform INIT into something like:
6682
6683                          (INIT, ({ CLEANUP_STMT; }))
6684
6685                      because emit_local_var always treats the
6686                      initializer as a full-expression.  Thus, the
6687                      destructor would run too early; it would run at the
6688                      end of initializing the reference variable, rather
6689                      than at the end of the block enclosing the
6690                      reference variable.
6691
6692                      The solution is to pass back a cleanup expression
6693                      which the caller is responsible for attaching to
6694                      the statement tree.  */
6695                 }
6696               else
6697                 {
6698                   rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6699                   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6700                     static_aggregates = tree_cons (NULL_TREE, var,
6701                                                    static_aggregates);
6702                 }
6703               /* Use its address to initialize the reference variable.  */
6704               expr = build_address (var);
6705               if (base_conv_type)
6706                 expr = convert_to_base (expr,
6707                                         build_pointer_type (base_conv_type),
6708                                         /*check_access=*/true,
6709                                         /*nonnull=*/true);
6710               expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6711             }
6712           else
6713             /* Take the address of EXPR.  */
6714             expr = build_unary_op (ADDR_EXPR, expr, 0);
6715           /* If a BASE_CONV was required, perform it now.  */
6716           if (base_conv_type)
6717             expr = (perform_implicit_conversion
6718                     (build_pointer_type (base_conv_type), expr));
6719           expr = build_nop (type, expr);
6720         }
6721     }
6722   else
6723     /* Perform the conversion.  */
6724     expr = convert_like (conv, expr);
6725
6726   /* Free all the conversions we allocated.  */
6727   obstack_free (&conversion_obstack, p);
6728
6729   return expr;
6730 }
6731
6732 #include "gt-cp-call.h"