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