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