gcc/cp/call.c

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