contrib/gcc/cp/call.c

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