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