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