search.c revision 1.3
1/* Breadth-first and depth-first routines for 2 searching multiple-inheritance lattice for GNU C++. 3 Copyright (C) 1987-2013 Free Software Foundation, Inc. 4 Contributed by Michael Tiemann (tiemann@cygnus.com) 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 3, or (at your option) 11any later version. 12 13GCC is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING3. If not see 20<http://www.gnu.org/licenses/>. */ 21 22/* High-level class interface. */ 23 24#include "config.h" 25#include "system.h" 26#include "coretypes.h" 27#include "tm.h" 28#include "tree.h" 29#include "cp-tree.h" 30#include "intl.h" 31#include "flags.h" 32#include "toplev.h" 33#include "target.h" 34 35static int is_subobject_of_p (tree, tree); 36static tree dfs_lookup_base (tree, void *); 37static tree dfs_dcast_hint_pre (tree, void *); 38static tree dfs_dcast_hint_post (tree, void *); 39static tree dfs_debug_mark (tree, void *); 40static tree dfs_walk_once_r (tree, tree (*pre_fn) (tree, void *), 41 tree (*post_fn) (tree, void *), void *data); 42static void dfs_unmark_r (tree); 43static int check_hidden_convs (tree, int, int, tree, tree, tree); 44static tree split_conversions (tree, tree, tree, tree); 45static int lookup_conversions_r (tree, int, int, 46 tree, tree, tree, tree, tree *, tree *); 47static int look_for_overrides_r (tree, tree); 48static tree lookup_field_r (tree, void *); 49static tree dfs_accessible_post (tree, void *); 50static tree dfs_walk_once_accessible_r (tree, bool, bool, 51 tree (*pre_fn) (tree, void *), 52 tree (*post_fn) (tree, void *), 53 void *data); 54static tree dfs_walk_once_accessible (tree, bool, 55 tree (*pre_fn) (tree, void *), 56 tree (*post_fn) (tree, void *), 57 void *data); 58static tree dfs_access_in_type (tree, void *); 59static access_kind access_in_type (tree, tree); 60static int protected_accessible_p (tree, tree, tree); 61static int friend_accessible_p (tree, tree, tree); 62static tree dfs_get_pure_virtuals (tree, void *); 63 64 65/* Variables for gathering statistics. */ 66static int n_fields_searched; 67static int n_calls_lookup_field, n_calls_lookup_field_1; 68static int n_calls_lookup_fnfields, n_calls_lookup_fnfields_1; 69static int n_calls_get_base_type; 70static int n_outer_fields_searched; 71static int n_contexts_saved; 72 73 74/* Data for lookup_base and its workers. */ 75 76struct lookup_base_data_s 77{ 78 tree t; /* type being searched. */ 79 tree base; /* The base type we're looking for. */ 80 tree binfo; /* Found binfo. */ 81 bool via_virtual; /* Found via a virtual path. */ 82 bool ambiguous; /* Found multiply ambiguous */ 83 bool repeated_base; /* Whether there are repeated bases in the 84 hierarchy. */ 85 bool want_any; /* Whether we want any matching binfo. */ 86}; 87 88/* Worker function for lookup_base. See if we've found the desired 89 base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */ 90 91static tree 92dfs_lookup_base (tree binfo, void *data_) 93{ 94 struct lookup_base_data_s *data = (struct lookup_base_data_s *) data_; 95 96 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->base)) 97 { 98 if (!data->binfo) 99 { 100 data->binfo = binfo; 101 data->via_virtual 102 = binfo_via_virtual (data->binfo, data->t) != NULL_TREE; 103 104 if (!data->repeated_base) 105 /* If there are no repeated bases, we can stop now. */ 106 return binfo; 107 108 if (data->want_any && !data->via_virtual) 109 /* If this is a non-virtual base, then we can't do 110 better. */ 111 return binfo; 112 113 return dfs_skip_bases; 114 } 115 else 116 { 117 gcc_assert (binfo != data->binfo); 118 119 /* We've found more than one matching binfo. */ 120 if (!data->want_any) 121 { 122 /* This is immediately ambiguous. */ 123 data->binfo = NULL_TREE; 124 data->ambiguous = true; 125 return error_mark_node; 126 } 127 128 /* Prefer one via a non-virtual path. */ 129 if (!binfo_via_virtual (binfo, data->t)) 130 { 131 data->binfo = binfo; 132 data->via_virtual = false; 133 return binfo; 134 } 135 136 /* There must be repeated bases, otherwise we'd have stopped 137 on the first base we found. */ 138 return dfs_skip_bases; 139 } 140 } 141 142 return NULL_TREE; 143} 144 145/* Returns true if type BASE is accessible in T. (BASE is known to be 146 a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is 147 true, consider any special access of the current scope, or access 148 bestowed by friendship. */ 149 150bool 151accessible_base_p (tree t, tree base, bool consider_local_p) 152{ 153 tree decl; 154 155 /* [class.access.base] 156 157 A base class is said to be accessible if an invented public 158 member of the base class is accessible. 159 160 If BASE is a non-proper base, this condition is trivially 161 true. */ 162 if (same_type_p (t, base)) 163 return true; 164 /* Rather than inventing a public member, we use the implicit 165 public typedef created in the scope of every class. */ 166 decl = TYPE_FIELDS (base); 167 while (!DECL_SELF_REFERENCE_P (decl)) 168 decl = DECL_CHAIN (decl); 169 while (ANON_AGGR_TYPE_P (t)) 170 t = TYPE_CONTEXT (t); 171 return accessible_p (t, decl, consider_local_p); 172} 173 174/* Lookup BASE in the hierarchy dominated by T. Do access checking as 175 ACCESS specifies. Return the binfo we discover. If KIND_PTR is 176 non-NULL, fill with information about what kind of base we 177 discovered. 178 179 If the base is inaccessible, or ambiguous, then error_mark_node is 180 returned. If the tf_error bit of COMPLAIN is not set, no error 181 is issued. */ 182 183tree 184lookup_base (tree t, tree base, base_access access, 185 base_kind *kind_ptr, tsubst_flags_t complain) 186{ 187 tree binfo; 188 tree t_binfo; 189 base_kind bk; 190 191 /* "Nothing" is definitely not derived from Base. */ 192 if (t == NULL_TREE) 193 { 194 if (kind_ptr) 195 *kind_ptr = bk_not_base; 196 return NULL_TREE; 197 } 198 199 if (t == error_mark_node || base == error_mark_node) 200 { 201 if (kind_ptr) 202 *kind_ptr = bk_not_base; 203 return error_mark_node; 204 } 205 gcc_assert (TYPE_P (base)); 206 207 if (!TYPE_P (t)) 208 { 209 t_binfo = t; 210 t = BINFO_TYPE (t); 211 } 212 else 213 { 214 t = complete_type (TYPE_MAIN_VARIANT (t)); 215 t_binfo = TYPE_BINFO (t); 216 } 217 218 base = TYPE_MAIN_VARIANT (base); 219 220 /* If BASE is incomplete, it can't be a base of T--and instantiating it 221 might cause an error. */ 222 if (t_binfo && CLASS_TYPE_P (base) && COMPLETE_OR_OPEN_TYPE_P (base)) 223 { 224 struct lookup_base_data_s data; 225 226 data.t = t; 227 data.base = base; 228 data.binfo = NULL_TREE; 229 data.ambiguous = data.via_virtual = false; 230 data.repeated_base = CLASSTYPE_REPEATED_BASE_P (t); 231 data.want_any = access == ba_any; 232 233 dfs_walk_once (t_binfo, dfs_lookup_base, NULL, &data); 234 binfo = data.binfo; 235 236 if (!binfo) 237 bk = data.ambiguous ? bk_ambig : bk_not_base; 238 else if (binfo == t_binfo) 239 bk = bk_same_type; 240 else if (data.via_virtual) 241 bk = bk_via_virtual; 242 else 243 bk = bk_proper_base; 244 } 245 else 246 { 247 binfo = NULL_TREE; 248 bk = bk_not_base; 249 } 250 251 /* Check that the base is unambiguous and accessible. */ 252 if (access != ba_any) 253 switch (bk) 254 { 255 case bk_not_base: 256 break; 257 258 case bk_ambig: 259 if (complain & tf_error) 260 error ("%qT is an ambiguous base of %qT", base, t); 261 binfo = error_mark_node; 262 break; 263 264 default: 265 if ((access & ba_check_bit) 266 /* If BASE is incomplete, then BASE and TYPE are probably 267 the same, in which case BASE is accessible. If they 268 are not the same, then TYPE is invalid. In that case, 269 there's no need to issue another error here, and 270 there's no implicit typedef to use in the code that 271 follows, so we skip the check. */ 272 && COMPLETE_TYPE_P (base) 273 && !accessible_base_p (t, base, !(access & ba_ignore_scope))) 274 { 275 if (complain & tf_error) 276 error ("%qT is an inaccessible base of %qT", base, t); 277 binfo = error_mark_node; 278 bk = bk_inaccessible; 279 } 280 break; 281 } 282 283 if (kind_ptr) 284 *kind_ptr = bk; 285 286 return binfo; 287} 288 289/* Data for dcast_base_hint walker. */ 290 291struct dcast_data_s 292{ 293 tree subtype; /* The base type we're looking for. */ 294 int virt_depth; /* Number of virtual bases encountered from most 295 derived. */ 296 tree offset; /* Best hint offset discovered so far. */ 297 bool repeated_base; /* Whether there are repeated bases in the 298 hierarchy. */ 299}; 300 301/* Worker for dcast_base_hint. Search for the base type being cast 302 from. */ 303 304static tree 305dfs_dcast_hint_pre (tree binfo, void *data_) 306{ 307 struct dcast_data_s *data = (struct dcast_data_s *) data_; 308 309 if (BINFO_VIRTUAL_P (binfo)) 310 data->virt_depth++; 311 312 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->subtype)) 313 { 314 if (data->virt_depth) 315 { 316 data->offset = ssize_int (-1); 317 return data->offset; 318 } 319 if (data->offset) 320 data->offset = ssize_int (-3); 321 else 322 data->offset = BINFO_OFFSET (binfo); 323 324 return data->repeated_base ? dfs_skip_bases : data->offset; 325 } 326 327 return NULL_TREE; 328} 329 330/* Worker for dcast_base_hint. Track the virtual depth. */ 331 332static tree 333dfs_dcast_hint_post (tree binfo, void *data_) 334{ 335 struct dcast_data_s *data = (struct dcast_data_s *) data_; 336 337 if (BINFO_VIRTUAL_P (binfo)) 338 data->virt_depth--; 339 340 return NULL_TREE; 341} 342 343/* The dynamic cast runtime needs a hint about how the static SUBTYPE type 344 started from is related to the required TARGET type, in order to optimize 345 the inheritance graph search. This information is independent of the 346 current context, and ignores private paths, hence get_base_distance is 347 inappropriate. Return a TREE specifying the base offset, BOFF. 348 BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF, 349 and there are no public virtual SUBTYPE bases. 350 BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases. 351 BOFF == -2, SUBTYPE is not a public base. 352 BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */ 353 354tree 355dcast_base_hint (tree subtype, tree target) 356{ 357 struct dcast_data_s data; 358 359 data.subtype = subtype; 360 data.virt_depth = 0; 361 data.offset = NULL_TREE; 362 data.repeated_base = CLASSTYPE_REPEATED_BASE_P (target); 363 364 dfs_walk_once_accessible (TYPE_BINFO (target), /*friends=*/false, 365 dfs_dcast_hint_pre, dfs_dcast_hint_post, &data); 366 return data.offset ? data.offset : ssize_int (-2); 367} 368 369/* Search for a member with name NAME in a multiple inheritance 370 lattice specified by TYPE. If it does not exist, return NULL_TREE. 371 If the member is ambiguously referenced, return `error_mark_node'. 372 Otherwise, return a DECL with the indicated name. If WANT_TYPE is 373 true, type declarations are preferred. */ 374 375/* Do a 1-level search for NAME as a member of TYPE. The caller must 376 figure out whether it can access this field. (Since it is only one 377 level, this is reasonable.) */ 378 379tree 380lookup_field_1 (tree type, tree name, bool want_type) 381{ 382 tree field; 383 384 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); 385 386 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM 387 || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM 388 || TREE_CODE (type) == TYPENAME_TYPE) 389 /* The TYPE_FIELDS of a TEMPLATE_TYPE_PARM and 390 BOUND_TEMPLATE_TEMPLATE_PARM are not fields at all; 391 instead TYPE_FIELDS is the TEMPLATE_PARM_INDEX. (Miraculously, 392 the code often worked even when we treated the index as a list 393 of fields!) 394 The TYPE_FIELDS of TYPENAME_TYPE is its TYPENAME_TYPE_FULLNAME. */ 395 return NULL_TREE; 396 397 if (CLASSTYPE_SORTED_FIELDS (type)) 398 { 399 tree *fields = &CLASSTYPE_SORTED_FIELDS (type)->elts[0]; 400 int lo = 0, hi = CLASSTYPE_SORTED_FIELDS (type)->len; 401 int i; 402 403 while (lo < hi) 404 { 405 i = (lo + hi) / 2; 406 407 if (GATHER_STATISTICS) 408 n_fields_searched++; 409 410 if (DECL_NAME (fields[i]) > name) 411 hi = i; 412 else if (DECL_NAME (fields[i]) < name) 413 lo = i + 1; 414 else 415 { 416 field = NULL_TREE; 417 418 /* We might have a nested class and a field with the 419 same name; we sorted them appropriately via 420 field_decl_cmp, so just look for the first or last 421 field with this name. */ 422 if (want_type) 423 { 424 do 425 field = fields[i--]; 426 while (i >= lo && DECL_NAME (fields[i]) == name); 427 if (TREE_CODE (field) != TYPE_DECL 428 && !DECL_TYPE_TEMPLATE_P (field)) 429 field = NULL_TREE; 430 } 431 else 432 { 433 do 434 field = fields[i++]; 435 while (i < hi && DECL_NAME (fields[i]) == name); 436 } 437 438 if (field) 439 { 440 field = strip_using_decl (field); 441 if (is_overloaded_fn (field)) 442 field = NULL_TREE; 443 } 444 445 return field; 446 } 447 } 448 return NULL_TREE; 449 } 450 451 field = TYPE_FIELDS (type); 452 453 if (GATHER_STATISTICS) 454 n_calls_lookup_field_1++; 455 456 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 457 { 458 tree decl = field; 459 460 if (GATHER_STATISTICS) 461 n_fields_searched++; 462 463 gcc_assert (DECL_P (field)); 464 if (DECL_NAME (field) == NULL_TREE 465 && ANON_AGGR_TYPE_P (TREE_TYPE (field))) 466 { 467 tree temp = lookup_field_1 (TREE_TYPE (field), name, want_type); 468 if (temp) 469 return temp; 470 } 471 472 if (TREE_CODE (decl) == USING_DECL 473 && DECL_NAME (decl) == name) 474 { 475 decl = strip_using_decl (decl); 476 if (is_overloaded_fn (decl)) 477 continue; 478 } 479 480 if (DECL_NAME (decl) == name 481 && (!want_type 482 || TREE_CODE (decl) == TYPE_DECL 483 || DECL_TYPE_TEMPLATE_P (decl))) 484 return decl; 485 } 486 /* Not found. */ 487 if (name == vptr_identifier) 488 { 489 /* Give the user what s/he thinks s/he wants. */ 490 if (TYPE_POLYMORPHIC_P (type)) 491 return TYPE_VFIELD (type); 492 } 493 return NULL_TREE; 494} 495 496/* Return the FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, or 497 NAMESPACE_DECL corresponding to the innermost non-block scope. */ 498 499tree 500current_scope (void) 501{ 502 /* There are a number of cases we need to be aware of here: 503 current_class_type current_function_decl 504 global NULL NULL 505 fn-local NULL SET 506 class-local SET NULL 507 class->fn SET SET 508 fn->class SET SET 509 510 Those last two make life interesting. If we're in a function which is 511 itself inside a class, we need decls to go into the fn's decls (our 512 second case below). But if we're in a class and the class itself is 513 inside a function, we need decls to go into the decls for the class. To 514 achieve this last goal, we must see if, when both current_class_ptr and 515 current_function_decl are set, the class was declared inside that 516 function. If so, we know to put the decls into the class's scope. */ 517 if (current_function_decl && current_class_type 518 && ((DECL_FUNCTION_MEMBER_P (current_function_decl) 519 && same_type_p (DECL_CONTEXT (current_function_decl), 520 current_class_type)) 521 || (DECL_FRIEND_CONTEXT (current_function_decl) 522 && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl), 523 current_class_type)))) 524 return current_function_decl; 525 if (current_class_type) 526 return current_class_type; 527 if (current_function_decl) 528 return current_function_decl; 529 return current_namespace; 530} 531 532/* Returns nonzero if we are currently in a function scope. Note 533 that this function returns zero if we are within a local class, but 534 not within a member function body of the local class. */ 535 536int 537at_function_scope_p (void) 538{ 539 tree cs = current_scope (); 540 /* Also check cfun to make sure that we're really compiling 541 this function (as opposed to having set current_function_decl 542 for access checking or some such). */ 543 return (cs && TREE_CODE (cs) == FUNCTION_DECL 544 && cfun && cfun->decl == current_function_decl); 545} 546 547/* Returns true if the innermost active scope is a class scope. */ 548 549bool 550at_class_scope_p (void) 551{ 552 tree cs = current_scope (); 553 return cs && TYPE_P (cs); 554} 555 556/* Returns true if the innermost active scope is a namespace scope. */ 557 558bool 559at_namespace_scope_p (void) 560{ 561 tree cs = current_scope (); 562 return cs && TREE_CODE (cs) == NAMESPACE_DECL; 563} 564 565/* Return the scope of DECL, as appropriate when doing name-lookup. */ 566 567tree 568context_for_name_lookup (tree decl) 569{ 570 /* [class.union] 571 572 For the purposes of name lookup, after the anonymous union 573 definition, the members of the anonymous union are considered to 574 have been defined in the scope in which the anonymous union is 575 declared. */ 576 tree context = DECL_CONTEXT (decl); 577 578 while (context && TYPE_P (context) 579 && (ANON_AGGR_TYPE_P (context) || UNSCOPED_ENUM_P (context))) 580 context = TYPE_CONTEXT (context); 581 if (!context) 582 context = global_namespace; 583 584 return context; 585} 586 587/* The accessibility routines use BINFO_ACCESS for scratch space 588 during the computation of the accessibility of some declaration. */ 589 590#define BINFO_ACCESS(NODE) \ 591 ((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE))) 592 593/* Set the access associated with NODE to ACCESS. */ 594 595#define SET_BINFO_ACCESS(NODE, ACCESS) \ 596 ((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \ 597 (TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0)) 598 599/* Called from access_in_type via dfs_walk. Calculate the access to 600 DATA (which is really a DECL) in BINFO. */ 601 602static tree 603dfs_access_in_type (tree binfo, void *data) 604{ 605 tree decl = (tree) data; 606 tree type = BINFO_TYPE (binfo); 607 access_kind access = ak_none; 608 609 if (context_for_name_lookup (decl) == type) 610 { 611 /* If we have descended to the scope of DECL, just note the 612 appropriate access. */ 613 if (TREE_PRIVATE (decl)) 614 access = ak_private; 615 else if (TREE_PROTECTED (decl)) 616 access = ak_protected; 617 else 618 access = ak_public; 619 } 620 else 621 { 622 /* First, check for an access-declaration that gives us more 623 access to the DECL. */ 624 if (DECL_LANG_SPECIFIC (decl) && !DECL_DISCRIMINATOR_P (decl)) 625 { 626 tree decl_access = purpose_member (type, DECL_ACCESS (decl)); 627 628 if (decl_access) 629 { 630 decl_access = TREE_VALUE (decl_access); 631 632 if (decl_access == access_public_node) 633 access = ak_public; 634 else if (decl_access == access_protected_node) 635 access = ak_protected; 636 else if (decl_access == access_private_node) 637 access = ak_private; 638 else 639 gcc_unreachable (); 640 } 641 } 642 643 if (!access) 644 { 645 int i; 646 tree base_binfo; 647 vec<tree, va_gc> *accesses; 648 649 /* Otherwise, scan our baseclasses, and pick the most favorable 650 access. */ 651 accesses = BINFO_BASE_ACCESSES (binfo); 652 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 653 { 654 tree base_access = (*accesses)[i]; 655 access_kind base_access_now = BINFO_ACCESS (base_binfo); 656 657 if (base_access_now == ak_none || base_access_now == ak_private) 658 /* If it was not accessible in the base, or only 659 accessible as a private member, we can't access it 660 all. */ 661 base_access_now = ak_none; 662 else if (base_access == access_protected_node) 663 /* Public and protected members in the base become 664 protected here. */ 665 base_access_now = ak_protected; 666 else if (base_access == access_private_node) 667 /* Public and protected members in the base become 668 private here. */ 669 base_access_now = ak_private; 670 671 /* See if the new access, via this base, gives more 672 access than our previous best access. */ 673 if (base_access_now != ak_none 674 && (access == ak_none || base_access_now < access)) 675 { 676 access = base_access_now; 677 678 /* If the new access is public, we can't do better. */ 679 if (access == ak_public) 680 break; 681 } 682 } 683 } 684 } 685 686 /* Note the access to DECL in TYPE. */ 687 SET_BINFO_ACCESS (binfo, access); 688 689 return NULL_TREE; 690} 691 692/* Return the access to DECL in TYPE. */ 693 694static access_kind 695access_in_type (tree type, tree decl) 696{ 697 tree binfo = TYPE_BINFO (type); 698 699 /* We must take into account 700 701 [class.paths] 702 703 If a name can be reached by several paths through a multiple 704 inheritance graph, the access is that of the path that gives 705 most access. 706 707 The algorithm we use is to make a post-order depth-first traversal 708 of the base-class hierarchy. As we come up the tree, we annotate 709 each node with the most lenient access. */ 710 dfs_walk_once (binfo, NULL, dfs_access_in_type, decl); 711 712 return BINFO_ACCESS (binfo); 713} 714 715/* Returns nonzero if it is OK to access DECL through an object 716 indicated by BINFO in the context of DERIVED. */ 717 718static int 719protected_accessible_p (tree decl, tree derived, tree binfo) 720{ 721 access_kind access; 722 723 /* We're checking this clause from [class.access.base] 724 725 m as a member of N is protected, and the reference occurs in a 726 member or friend of class N, or in a member or friend of a 727 class P derived from N, where m as a member of P is public, private 728 or protected. 729 730 Here DERIVED is a possible P, DECL is m and BINFO_TYPE (binfo) is N. */ 731 732 /* If DERIVED isn't derived from N, then it can't be a P. */ 733 if (!DERIVED_FROM_P (BINFO_TYPE (binfo), derived)) 734 return 0; 735 736 access = access_in_type (derived, decl); 737 738 /* If m is inaccessible in DERIVED, then it's not a P. */ 739 if (access == ak_none) 740 return 0; 741 742 /* [class.protected] 743 744 When a friend or a member function of a derived class references 745 a protected nonstatic member of a base class, an access check 746 applies in addition to those described earlier in clause 747 _class.access_) Except when forming a pointer to member 748 (_expr.unary.op_), the access must be through a pointer to, 749 reference to, or object of the derived class itself (or any class 750 derived from that class) (_expr.ref_). If the access is to form 751 a pointer to member, the nested-name-specifier shall name the 752 derived class (or any class derived from that class). */ 753 if (DECL_NONSTATIC_MEMBER_P (decl)) 754 { 755 /* We can tell through what the reference is occurring by 756 chasing BINFO up to the root. */ 757 tree t = binfo; 758 while (BINFO_INHERITANCE_CHAIN (t)) 759 t = BINFO_INHERITANCE_CHAIN (t); 760 761 if (!DERIVED_FROM_P (derived, BINFO_TYPE (t))) 762 return 0; 763 } 764 765 return 1; 766} 767 768/* Returns nonzero if SCOPE is a friend of a type which would be able 769 to access DECL through the object indicated by BINFO. */ 770 771static int 772friend_accessible_p (tree scope, tree decl, tree binfo) 773{ 774 tree befriending_classes; 775 tree t; 776 777 if (!scope) 778 return 0; 779 780 if (TREE_CODE (scope) == FUNCTION_DECL 781 || DECL_FUNCTION_TEMPLATE_P (scope)) 782 befriending_classes = DECL_BEFRIENDING_CLASSES (scope); 783 else if (TYPE_P (scope)) 784 befriending_classes = CLASSTYPE_BEFRIENDING_CLASSES (scope); 785 else 786 return 0; 787 788 for (t = befriending_classes; t; t = TREE_CHAIN (t)) 789 if (protected_accessible_p (decl, TREE_VALUE (t), binfo)) 790 return 1; 791 792 /* Nested classes have the same access as their enclosing types, as 793 per DR 45 (this is a change from the standard). */ 794 if (TYPE_P (scope)) 795 for (t = TYPE_CONTEXT (scope); t && TYPE_P (t); t = TYPE_CONTEXT (t)) 796 if (protected_accessible_p (decl, t, binfo)) 797 return 1; 798 799 if (TREE_CODE (scope) == FUNCTION_DECL 800 || DECL_FUNCTION_TEMPLATE_P (scope)) 801 { 802 /* Perhaps this SCOPE is a member of a class which is a 803 friend. */ 804 if (DECL_CLASS_SCOPE_P (scope) 805 && friend_accessible_p (DECL_CONTEXT (scope), decl, binfo)) 806 return 1; 807 808 /* Or an instantiation of something which is a friend. */ 809 if (DECL_TEMPLATE_INFO (scope)) 810 { 811 int ret; 812 /* Increment processing_template_decl to make sure that 813 dependent_type_p works correctly. */ 814 ++processing_template_decl; 815 ret = friend_accessible_p (DECL_TI_TEMPLATE (scope), decl, binfo); 816 --processing_template_decl; 817 return ret; 818 } 819 } 820 821 return 0; 822} 823 824/* Called via dfs_walk_once_accessible from accessible_p */ 825 826static tree 827dfs_accessible_post (tree binfo, void * /*data*/) 828{ 829 if (BINFO_ACCESS (binfo) != ak_none) 830 { 831 tree scope = current_scope (); 832 if (scope && TREE_CODE (scope) != NAMESPACE_DECL 833 && is_friend (BINFO_TYPE (binfo), scope)) 834 return binfo; 835 } 836 837 return NULL_TREE; 838} 839 840/* Like accessible_p below, but within a template returns true iff DECL is 841 accessible in TYPE to all possible instantiations of the template. */ 842 843int 844accessible_in_template_p (tree type, tree decl) 845{ 846 int save_ptd = processing_template_decl; 847 processing_template_decl = 0; 848 int val = accessible_p (type, decl, false); 849 processing_template_decl = save_ptd; 850 return val; 851} 852 853/* DECL is a declaration from a base class of TYPE, which was the 854 class used to name DECL. Return nonzero if, in the current 855 context, DECL is accessible. If TYPE is actually a BINFO node, 856 then we can tell in what context the access is occurring by looking 857 at the most derived class along the path indicated by BINFO. If 858 CONSIDER_LOCAL is true, do consider special access the current 859 scope or friendship thereof we might have. */ 860 861int 862accessible_p (tree type, tree decl, bool consider_local_p) 863{ 864 tree binfo; 865 tree scope; 866 access_kind access; 867 868 /* Nonzero if it's OK to access DECL if it has protected 869 accessibility in TYPE. */ 870 int protected_ok = 0; 871 872 /* If this declaration is in a block or namespace scope, there's no 873 access control. */ 874 if (!TYPE_P (context_for_name_lookup (decl))) 875 return 1; 876 877 /* There is no need to perform access checks inside a thunk. */ 878 scope = current_scope (); 879 if (scope && DECL_THUNK_P (scope)) 880 return 1; 881 882 /* In a template declaration, we cannot be sure whether the 883 particular specialization that is instantiated will be a friend 884 or not. Therefore, all access checks are deferred until 885 instantiation. However, PROCESSING_TEMPLATE_DECL is set in the 886 parameter list for a template (because we may see dependent types 887 in default arguments for template parameters), and access 888 checking should be performed in the outermost parameter list. */ 889 if (processing_template_decl 890 && (!processing_template_parmlist || processing_template_decl > 1)) 891 return 1; 892 893 if (!TYPE_P (type)) 894 { 895 binfo = type; 896 type = BINFO_TYPE (type); 897 } 898 else 899 binfo = TYPE_BINFO (type); 900 901 /* [class.access.base] 902 903 A member m is accessible when named in class N if 904 905 --m as a member of N is public, or 906 907 --m as a member of N is private, and the reference occurs in a 908 member or friend of class N, or 909 910 --m as a member of N is protected, and the reference occurs in a 911 member or friend of class N, or in a member or friend of a 912 class P derived from N, where m as a member of P is private or 913 protected, or 914 915 --there exists a base class B of N that is accessible at the point 916 of reference, and m is accessible when named in class B. 917 918 We walk the base class hierarchy, checking these conditions. */ 919 920 if (consider_local_p) 921 { 922 /* Figure out where the reference is occurring. Check to see if 923 DECL is private or protected in this scope, since that will 924 determine whether protected access is allowed. */ 925 if (current_class_type) 926 protected_ok = protected_accessible_p (decl, 927 current_class_type, binfo); 928 929 /* Now, loop through the classes of which we are a friend. */ 930 if (!protected_ok) 931 protected_ok = friend_accessible_p (scope, decl, binfo); 932 } 933 934 /* Standardize the binfo that access_in_type will use. We don't 935 need to know what path was chosen from this point onwards. */ 936 binfo = TYPE_BINFO (type); 937 938 /* Compute the accessibility of DECL in the class hierarchy 939 dominated by type. */ 940 access = access_in_type (type, decl); 941 if (access == ak_public 942 || (access == ak_protected && protected_ok)) 943 return 1; 944 945 if (!consider_local_p) 946 return 0; 947 948 /* Walk the hierarchy again, looking for a base class that allows 949 access. */ 950 return dfs_walk_once_accessible (binfo, /*friends=*/true, 951 NULL, dfs_accessible_post, NULL) 952 != NULL_TREE; 953} 954 955struct lookup_field_info { 956 /* The type in which we're looking. */ 957 tree type; 958 /* The name of the field for which we're looking. */ 959 tree name; 960 /* If non-NULL, the current result of the lookup. */ 961 tree rval; 962 /* The path to RVAL. */ 963 tree rval_binfo; 964 /* If non-NULL, the lookup was ambiguous, and this is a list of the 965 candidates. */ 966 tree ambiguous; 967 /* If nonzero, we are looking for types, not data members. */ 968 int want_type; 969 /* If something went wrong, a message indicating what. */ 970 const char *errstr; 971}; 972 973/* Nonzero for a class member means that it is shared between all objects 974 of that class. 975 976 [class.member.lookup]:If the resulting set of declarations are not all 977 from sub-objects of the same type, or the set has a nonstatic member 978 and includes members from distinct sub-objects, there is an ambiguity 979 and the program is ill-formed. 980 981 This function checks that T contains no nonstatic members. */ 982 983int 984shared_member_p (tree t) 985{ 986 if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == TYPE_DECL \ 987 || TREE_CODE (t) == CONST_DECL) 988 return 1; 989 if (is_overloaded_fn (t)) 990 { 991 t = get_fns (t); 992 for (; t; t = OVL_NEXT (t)) 993 { 994 tree fn = OVL_CURRENT (t); 995 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)) 996 return 0; 997 } 998 return 1; 999 } 1000 return 0; 1001} 1002 1003/* Routine to see if the sub-object denoted by the binfo PARENT can be 1004 found as a base class and sub-object of the object denoted by 1005 BINFO. */ 1006 1007static int 1008is_subobject_of_p (tree parent, tree binfo) 1009{ 1010 tree probe; 1011 1012 for (probe = parent; probe; probe = BINFO_INHERITANCE_CHAIN (probe)) 1013 { 1014 if (probe == binfo) 1015 return 1; 1016 if (BINFO_VIRTUAL_P (probe)) 1017 return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (binfo)) 1018 != NULL_TREE); 1019 } 1020 return 0; 1021} 1022 1023/* DATA is really a struct lookup_field_info. Look for a field with 1024 the name indicated there in BINFO. If this function returns a 1025 non-NULL value it is the result of the lookup. Called from 1026 lookup_field via breadth_first_search. */ 1027 1028static tree 1029lookup_field_r (tree binfo, void *data) 1030{ 1031 struct lookup_field_info *lfi = (struct lookup_field_info *) data; 1032 tree type = BINFO_TYPE (binfo); 1033 tree nval = NULL_TREE; 1034 1035 /* If this is a dependent base, don't look in it. */ 1036 if (BINFO_DEPENDENT_BASE_P (binfo)) 1037 return NULL_TREE; 1038 1039 /* If this base class is hidden by the best-known value so far, we 1040 don't need to look. */ 1041 if (lfi->rval_binfo && BINFO_INHERITANCE_CHAIN (binfo) == lfi->rval_binfo 1042 && !BINFO_VIRTUAL_P (binfo)) 1043 return dfs_skip_bases; 1044 1045 /* First, look for a function. There can't be a function and a data 1046 member with the same name, and if there's a function and a type 1047 with the same name, the type is hidden by the function. */ 1048 if (!lfi->want_type) 1049 nval = lookup_fnfields_slot (type, lfi->name); 1050 1051 if (!nval) 1052 /* Look for a data member or type. */ 1053 nval = lookup_field_1 (type, lfi->name, lfi->want_type); 1054 1055 /* If there is no declaration with the indicated name in this type, 1056 then there's nothing to do. */ 1057 if (!nval) 1058 goto done; 1059 1060 /* If we're looking up a type (as with an elaborated type specifier) 1061 we ignore all non-types we find. */ 1062 if (lfi->want_type && TREE_CODE (nval) != TYPE_DECL 1063 && !DECL_TYPE_TEMPLATE_P (nval)) 1064 { 1065 if (lfi->name == TYPE_IDENTIFIER (type)) 1066 { 1067 /* If the aggregate has no user defined constructors, we allow 1068 it to have fields with the same name as the enclosing type. 1069 If we are looking for that name, find the corresponding 1070 TYPE_DECL. */ 1071 for (nval = TREE_CHAIN (nval); nval; nval = TREE_CHAIN (nval)) 1072 if (DECL_NAME (nval) == lfi->name 1073 && TREE_CODE (nval) == TYPE_DECL) 1074 break; 1075 } 1076 else 1077 nval = NULL_TREE; 1078 if (!nval && CLASSTYPE_NESTED_UTDS (type) != NULL) 1079 { 1080 binding_entry e = binding_table_find (CLASSTYPE_NESTED_UTDS (type), 1081 lfi->name); 1082 if (e != NULL) 1083 nval = TYPE_MAIN_DECL (e->type); 1084 else 1085 goto done; 1086 } 1087 } 1088 1089 /* If the lookup already found a match, and the new value doesn't 1090 hide the old one, we might have an ambiguity. */ 1091 if (lfi->rval_binfo 1092 && !is_subobject_of_p (lfi->rval_binfo, binfo)) 1093 1094 { 1095 if (nval == lfi->rval && shared_member_p (nval)) 1096 /* The two things are really the same. */ 1097 ; 1098 else if (is_subobject_of_p (binfo, lfi->rval_binfo)) 1099 /* The previous value hides the new one. */ 1100 ; 1101 else 1102 { 1103 /* We have a real ambiguity. We keep a chain of all the 1104 candidates. */ 1105 if (!lfi->ambiguous && lfi->rval) 1106 { 1107 /* This is the first time we noticed an ambiguity. Add 1108 what we previously thought was a reasonable candidate 1109 to the list. */ 1110 lfi->ambiguous = tree_cons (NULL_TREE, lfi->rval, NULL_TREE); 1111 TREE_TYPE (lfi->ambiguous) = error_mark_node; 1112 } 1113 1114 /* Add the new value. */ 1115 lfi->ambiguous = tree_cons (NULL_TREE, nval, lfi->ambiguous); 1116 TREE_TYPE (lfi->ambiguous) = error_mark_node; 1117 lfi->errstr = G_("request for member %qD is ambiguous"); 1118 } 1119 } 1120 else 1121 { 1122 lfi->rval = nval; 1123 lfi->rval_binfo = binfo; 1124 } 1125 1126 done: 1127 /* Don't look for constructors or destructors in base classes. */ 1128 if (IDENTIFIER_CTOR_OR_DTOR_P (lfi->name)) 1129 return dfs_skip_bases; 1130 return NULL_TREE; 1131} 1132 1133/* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO, 1134 BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO, 1135 FUNCTIONS, and OPTYPE respectively. */ 1136 1137tree 1138build_baselink (tree binfo, tree access_binfo, tree functions, tree optype) 1139{ 1140 tree baselink; 1141 1142 gcc_assert (TREE_CODE (functions) == FUNCTION_DECL 1143 || TREE_CODE (functions) == TEMPLATE_DECL 1144 || TREE_CODE (functions) == TEMPLATE_ID_EXPR 1145 || TREE_CODE (functions) == OVERLOAD); 1146 gcc_assert (!optype || TYPE_P (optype)); 1147 gcc_assert (TREE_TYPE (functions)); 1148 1149 baselink = make_node (BASELINK); 1150 TREE_TYPE (baselink) = TREE_TYPE (functions); 1151 BASELINK_BINFO (baselink) = binfo; 1152 BASELINK_ACCESS_BINFO (baselink) = access_binfo; 1153 BASELINK_FUNCTIONS (baselink) = functions; 1154 BASELINK_OPTYPE (baselink) = optype; 1155 1156 return baselink; 1157} 1158 1159/* Look for a member named NAME in an inheritance lattice dominated by 1160 XBASETYPE. If PROTECT is 0 or two, we do not check access. If it 1161 is 1, we enforce accessibility. If PROTECT is zero, then, for an 1162 ambiguous lookup, we return NULL. If PROTECT is 1, we issue error 1163 messages about inaccessible or ambiguous lookup. If PROTECT is 2, 1164 we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose 1165 TREE_VALUEs are the list of ambiguous candidates. 1166 1167 WANT_TYPE is 1 when we should only return TYPE_DECLs. 1168 1169 If nothing can be found return NULL_TREE and do not issue an error. */ 1170 1171tree 1172lookup_member (tree xbasetype, tree name, int protect, bool want_type, 1173 tsubst_flags_t complain) 1174{ 1175 tree rval, rval_binfo = NULL_TREE; 1176 tree type = NULL_TREE, basetype_path = NULL_TREE; 1177 struct lookup_field_info lfi; 1178 1179 /* rval_binfo is the binfo associated with the found member, note, 1180 this can be set with useful information, even when rval is not 1181 set, because it must deal with ALL members, not just non-function 1182 members. It is used for ambiguity checking and the hidden 1183 checks. Whereas rval is only set if a proper (not hidden) 1184 non-function member is found. */ 1185 1186 const char *errstr = 0; 1187 1188 if (name == error_mark_node 1189 || xbasetype == NULL_TREE 1190 || xbasetype == error_mark_node) 1191 return NULL_TREE; 1192 1193 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); 1194 1195 if (TREE_CODE (xbasetype) == TREE_BINFO) 1196 { 1197 type = BINFO_TYPE (xbasetype); 1198 basetype_path = xbasetype; 1199 } 1200 else 1201 { 1202 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype))) 1203 return NULL_TREE; 1204 type = xbasetype; 1205 xbasetype = NULL_TREE; 1206 } 1207 1208 type = complete_type (type); 1209 if (!basetype_path) 1210 basetype_path = TYPE_BINFO (type); 1211 1212 if (!basetype_path) 1213 return NULL_TREE; 1214 1215 if (GATHER_STATISTICS) 1216 n_calls_lookup_field++; 1217 1218 memset (&lfi, 0, sizeof (lfi)); 1219 lfi.type = type; 1220 lfi.name = name; 1221 lfi.want_type = want_type; 1222 dfs_walk_all (basetype_path, &lookup_field_r, NULL, &lfi); 1223 rval = lfi.rval; 1224 rval_binfo = lfi.rval_binfo; 1225 if (rval_binfo) 1226 type = BINFO_TYPE (rval_binfo); 1227 errstr = lfi.errstr; 1228 1229 /* If we are not interested in ambiguities, don't report them; 1230 just return NULL_TREE. */ 1231 if (!protect && lfi.ambiguous) 1232 return NULL_TREE; 1233 1234 if (protect == 2) 1235 { 1236 if (lfi.ambiguous) 1237 return lfi.ambiguous; 1238 else 1239 protect = 0; 1240 } 1241 1242 /* [class.access] 1243 1244 In the case of overloaded function names, access control is 1245 applied to the function selected by overloaded resolution. 1246 1247 We cannot check here, even if RVAL is only a single non-static 1248 member function, since we do not know what the "this" pointer 1249 will be. For: 1250 1251 class A { protected: void f(); }; 1252 class B : public A { 1253 void g(A *p) { 1254 f(); // OK 1255 p->f(); // Not OK. 1256 } 1257 }; 1258 1259 only the first call to "f" is valid. However, if the function is 1260 static, we can check. */ 1261 if (rval && protect 1262 && !really_overloaded_fn (rval)) 1263 { 1264 tree decl = is_overloaded_fn (rval) ? get_first_fn (rval) : rval; 1265 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl) 1266 && !perform_or_defer_access_check (basetype_path, decl, decl, 1267 complain)) 1268 rval = error_mark_node; 1269 } 1270 1271 if (errstr && protect) 1272 { 1273 if (complain & tf_error) 1274 { 1275 error (errstr, name, type); 1276 if (lfi.ambiguous) 1277 print_candidates (lfi.ambiguous); 1278 } 1279 rval = error_mark_node; 1280 } 1281 1282 if (rval && is_overloaded_fn (rval)) 1283 rval = build_baselink (rval_binfo, basetype_path, rval, 1284 (IDENTIFIER_TYPENAME_P (name) 1285 ? TREE_TYPE (name): NULL_TREE)); 1286 return rval; 1287} 1288 1289/* Like lookup_member, except that if we find a function member we 1290 return NULL_TREE. */ 1291 1292tree 1293lookup_field (tree xbasetype, tree name, int protect, bool want_type) 1294{ 1295 tree rval = lookup_member (xbasetype, name, protect, want_type, 1296 tf_warning_or_error); 1297 1298 /* Ignore functions, but propagate the ambiguity list. */ 1299 if (!error_operand_p (rval) 1300 && (rval && BASELINK_P (rval))) 1301 return NULL_TREE; 1302 1303 return rval; 1304} 1305 1306/* Like lookup_member, except that if we find a non-function member we 1307 return NULL_TREE. */ 1308 1309tree 1310lookup_fnfields (tree xbasetype, tree name, int protect) 1311{ 1312 tree rval = lookup_member (xbasetype, name, protect, /*want_type=*/false, 1313 tf_warning_or_error); 1314 1315 /* Ignore non-functions, but propagate the ambiguity list. */ 1316 if (!error_operand_p (rval) 1317 && (rval && !BASELINK_P (rval))) 1318 return NULL_TREE; 1319 1320 return rval; 1321} 1322 1323/* Return the index in the CLASSTYPE_METHOD_VEC for CLASS_TYPE 1324 corresponding to "operator TYPE ()", or -1 if there is no such 1325 operator. Only CLASS_TYPE itself is searched; this routine does 1326 not scan the base classes of CLASS_TYPE. */ 1327 1328static int 1329lookup_conversion_operator (tree class_type, tree type) 1330{ 1331 int tpl_slot = -1; 1332 1333 if (TYPE_HAS_CONVERSION (class_type)) 1334 { 1335 int i; 1336 tree fn; 1337 vec<tree, va_gc> *methods = CLASSTYPE_METHOD_VEC (class_type); 1338 1339 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT; 1340 vec_safe_iterate (methods, i, &fn); ++i) 1341 { 1342 /* All the conversion operators come near the beginning of 1343 the class. Therefore, if FN is not a conversion 1344 operator, there is no matching conversion operator in 1345 CLASS_TYPE. */ 1346 fn = OVL_CURRENT (fn); 1347 if (!DECL_CONV_FN_P (fn)) 1348 break; 1349 1350 if (TREE_CODE (fn) == TEMPLATE_DECL) 1351 /* All the templated conversion functions are on the same 1352 slot, so remember it. */ 1353 tpl_slot = i; 1354 else if (same_type_p (DECL_CONV_FN_TYPE (fn), type)) 1355 return i; 1356 } 1357 } 1358 1359 return tpl_slot; 1360} 1361 1362/* TYPE is a class type. Return the index of the fields within 1363 the method vector with name NAME, or -1 if no such field exists. 1364 Does not lazily declare implicitly-declared member functions. */ 1365 1366static int 1367lookup_fnfields_idx_nolazy (tree type, tree name) 1368{ 1369 vec<tree, va_gc> *method_vec; 1370 tree fn; 1371 tree tmp; 1372 size_t i; 1373 1374 if (!CLASS_TYPE_P (type)) 1375 return -1; 1376 1377 method_vec = CLASSTYPE_METHOD_VEC (type); 1378 if (!method_vec) 1379 return -1; 1380 1381 if (GATHER_STATISTICS) 1382 n_calls_lookup_fnfields_1++; 1383 1384 /* Constructors are first... */ 1385 if (name == ctor_identifier) 1386 { 1387 fn = CLASSTYPE_CONSTRUCTORS (type); 1388 return fn ? CLASSTYPE_CONSTRUCTOR_SLOT : -1; 1389 } 1390 /* and destructors are second. */ 1391 if (name == dtor_identifier) 1392 { 1393 fn = CLASSTYPE_DESTRUCTORS (type); 1394 return fn ? CLASSTYPE_DESTRUCTOR_SLOT : -1; 1395 } 1396 if (IDENTIFIER_TYPENAME_P (name)) 1397 return lookup_conversion_operator (type, TREE_TYPE (name)); 1398 1399 /* Skip the conversion operators. */ 1400 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT; 1401 vec_safe_iterate (method_vec, i, &fn); 1402 ++i) 1403 if (!DECL_CONV_FN_P (OVL_CURRENT (fn))) 1404 break; 1405 1406 /* If the type is complete, use binary search. */ 1407 if (COMPLETE_TYPE_P (type)) 1408 { 1409 int lo; 1410 int hi; 1411 1412 lo = i; 1413 hi = method_vec->length (); 1414 while (lo < hi) 1415 { 1416 i = (lo + hi) / 2; 1417 1418 if (GATHER_STATISTICS) 1419 n_outer_fields_searched++; 1420 1421 tmp = (*method_vec)[i]; 1422 tmp = DECL_NAME (OVL_CURRENT (tmp)); 1423 if (tmp > name) 1424 hi = i; 1425 else if (tmp < name) 1426 lo = i + 1; 1427 else 1428 return i; 1429 } 1430 } 1431 else 1432 for (; vec_safe_iterate (method_vec, i, &fn); ++i) 1433 { 1434 if (GATHER_STATISTICS) 1435 n_outer_fields_searched++; 1436 if (DECL_NAME (OVL_CURRENT (fn)) == name) 1437 return i; 1438 } 1439 1440 return -1; 1441} 1442 1443/* TYPE is a class type. Return the index of the fields within 1444 the method vector with name NAME, or -1 if no such field exists. */ 1445 1446int 1447lookup_fnfields_1 (tree type, tree name) 1448{ 1449 if (!CLASS_TYPE_P (type)) 1450 return -1; 1451 1452 if (COMPLETE_TYPE_P (type)) 1453 { 1454 if ((name == ctor_identifier 1455 || name == base_ctor_identifier 1456 || name == complete_ctor_identifier)) 1457 { 1458 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type)) 1459 lazily_declare_fn (sfk_constructor, type); 1460 if (CLASSTYPE_LAZY_COPY_CTOR (type)) 1461 lazily_declare_fn (sfk_copy_constructor, type); 1462 if (CLASSTYPE_LAZY_MOVE_CTOR (type)) 1463 lazily_declare_fn (sfk_move_constructor, type); 1464 } 1465 else if (name == ansi_assopname (NOP_EXPR)) 1466 { 1467 if (CLASSTYPE_LAZY_COPY_ASSIGN (type)) 1468 lazily_declare_fn (sfk_copy_assignment, type); 1469 if (CLASSTYPE_LAZY_MOVE_ASSIGN (type)) 1470 lazily_declare_fn (sfk_move_assignment, type); 1471 } 1472 else if ((name == dtor_identifier 1473 || name == base_dtor_identifier 1474 || name == complete_dtor_identifier 1475 || name == deleting_dtor_identifier) 1476 && CLASSTYPE_LAZY_DESTRUCTOR (type)) 1477 lazily_declare_fn (sfk_destructor, type); 1478 } 1479 1480 return lookup_fnfields_idx_nolazy (type, name); 1481} 1482 1483/* TYPE is a class type. Return the field within the method vector with 1484 name NAME, or NULL_TREE if no such field exists. */ 1485 1486tree 1487lookup_fnfields_slot (tree type, tree name) 1488{ 1489 int ix = lookup_fnfields_1 (complete_type (type), name); 1490 if (ix < 0) 1491 return NULL_TREE; 1492 return (*CLASSTYPE_METHOD_VEC (type))[ix]; 1493} 1494 1495/* As above, but avoid lazily declaring functions. */ 1496 1497tree 1498lookup_fnfields_slot_nolazy (tree type, tree name) 1499{ 1500 int ix = lookup_fnfields_idx_nolazy (complete_type (type), name); 1501 if (ix < 0) 1502 return NULL_TREE; 1503 return (*CLASSTYPE_METHOD_VEC (type))[ix]; 1504} 1505 1506/* Like lookup_fnfields_1, except that the name is extracted from 1507 FUNCTION, which is a FUNCTION_DECL or a TEMPLATE_DECL. */ 1508 1509int 1510class_method_index_for_fn (tree class_type, tree function) 1511{ 1512 gcc_assert (TREE_CODE (function) == FUNCTION_DECL 1513 || DECL_FUNCTION_TEMPLATE_P (function)); 1514 1515 return lookup_fnfields_1 (class_type, 1516 DECL_CONSTRUCTOR_P (function) ? ctor_identifier : 1517 DECL_DESTRUCTOR_P (function) ? dtor_identifier : 1518 DECL_NAME (function)); 1519} 1520 1521 1522/* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is 1523 the class or namespace used to qualify the name. CONTEXT_CLASS is 1524 the class corresponding to the object in which DECL will be used. 1525 Return a possibly modified version of DECL that takes into account 1526 the CONTEXT_CLASS. 1527 1528 In particular, consider an expression like `B::m' in the context of 1529 a derived class `D'. If `B::m' has been resolved to a BASELINK, 1530 then the most derived class indicated by the BASELINK_BINFO will be 1531 `B', not `D'. This function makes that adjustment. */ 1532 1533tree 1534adjust_result_of_qualified_name_lookup (tree decl, 1535 tree qualifying_scope, 1536 tree context_class) 1537{ 1538 if (context_class && context_class != error_mark_node 1539 && CLASS_TYPE_P (context_class) 1540 && CLASS_TYPE_P (qualifying_scope) 1541 && DERIVED_FROM_P (qualifying_scope, context_class) 1542 && BASELINK_P (decl)) 1543 { 1544 tree base; 1545 1546 /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS. 1547 Because we do not yet know which function will be chosen by 1548 overload resolution, we cannot yet check either accessibility 1549 or ambiguity -- in either case, the choice of a static member 1550 function might make the usage valid. */ 1551 base = lookup_base (context_class, qualifying_scope, 1552 ba_unique, NULL, tf_none); 1553 if (base && base != error_mark_node) 1554 { 1555 BASELINK_ACCESS_BINFO (decl) = base; 1556 BASELINK_BINFO (decl) 1557 = lookup_base (base, BINFO_TYPE (BASELINK_BINFO (decl)), 1558 ba_unique, NULL, tf_none); 1559 } 1560 } 1561 1562 if (BASELINK_P (decl)) 1563 BASELINK_QUALIFIED_P (decl) = true; 1564 1565 return decl; 1566} 1567 1568 1569/* Walk the class hierarchy within BINFO, in a depth-first traversal. 1570 PRE_FN is called in preorder, while POST_FN is called in postorder. 1571 If PRE_FN returns DFS_SKIP_BASES, child binfos will not be 1572 walked. If PRE_FN or POST_FN returns a different non-NULL value, 1573 that value is immediately returned and the walk is terminated. One 1574 of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and 1575 POST_FN are passed the binfo to examine and the caller's DATA 1576 value. All paths are walked, thus virtual and morally virtual 1577 binfos can be multiply walked. */ 1578 1579tree 1580dfs_walk_all (tree binfo, tree (*pre_fn) (tree, void *), 1581 tree (*post_fn) (tree, void *), void *data) 1582{ 1583 tree rval; 1584 unsigned ix; 1585 tree base_binfo; 1586 1587 /* Call the pre-order walking function. */ 1588 if (pre_fn) 1589 { 1590 rval = pre_fn (binfo, data); 1591 if (rval) 1592 { 1593 if (rval == dfs_skip_bases) 1594 goto skip_bases; 1595 return rval; 1596 } 1597 } 1598 1599 /* Find the next child binfo to walk. */ 1600 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++) 1601 { 1602 rval = dfs_walk_all (base_binfo, pre_fn, post_fn, data); 1603 if (rval) 1604 return rval; 1605 } 1606 1607 skip_bases: 1608 /* Call the post-order walking function. */ 1609 if (post_fn) 1610 { 1611 rval = post_fn (binfo, data); 1612 gcc_assert (rval != dfs_skip_bases); 1613 return rval; 1614 } 1615 1616 return NULL_TREE; 1617} 1618 1619/* Worker for dfs_walk_once. This behaves as dfs_walk_all, except 1620 that binfos are walked at most once. */ 1621 1622static tree 1623dfs_walk_once_r (tree binfo, tree (*pre_fn) (tree, void *), 1624 tree (*post_fn) (tree, void *), void *data) 1625{ 1626 tree rval; 1627 unsigned ix; 1628 tree base_binfo; 1629 1630 /* Call the pre-order walking function. */ 1631 if (pre_fn) 1632 { 1633 rval = pre_fn (binfo, data); 1634 if (rval) 1635 { 1636 if (rval == dfs_skip_bases) 1637 goto skip_bases; 1638 1639 return rval; 1640 } 1641 } 1642 1643 /* Find the next child binfo to walk. */ 1644 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++) 1645 { 1646 if (BINFO_VIRTUAL_P (base_binfo)) 1647 { 1648 if (BINFO_MARKED (base_binfo)) 1649 continue; 1650 BINFO_MARKED (base_binfo) = 1; 1651 } 1652 1653 rval = dfs_walk_once_r (base_binfo, pre_fn, post_fn, data); 1654 if (rval) 1655 return rval; 1656 } 1657 1658 skip_bases: 1659 /* Call the post-order walking function. */ 1660 if (post_fn) 1661 { 1662 rval = post_fn (binfo, data); 1663 gcc_assert (rval != dfs_skip_bases); 1664 return rval; 1665 } 1666 1667 return NULL_TREE; 1668} 1669 1670/* Worker for dfs_walk_once. Recursively unmark the virtual base binfos of 1671 BINFO. */ 1672 1673static void 1674dfs_unmark_r (tree binfo) 1675{ 1676 unsigned ix; 1677 tree base_binfo; 1678 1679 /* Process the basetypes. */ 1680 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++) 1681 { 1682 if (BINFO_VIRTUAL_P (base_binfo)) 1683 { 1684 if (!BINFO_MARKED (base_binfo)) 1685 continue; 1686 BINFO_MARKED (base_binfo) = 0; 1687 } 1688 /* Only walk, if it can contain more virtual bases. */ 1689 if (CLASSTYPE_VBASECLASSES (BINFO_TYPE (base_binfo))) 1690 dfs_unmark_r (base_binfo); 1691 } 1692} 1693 1694/* Like dfs_walk_all, except that binfos are not multiply walked. For 1695 non-diamond shaped hierarchies this is the same as dfs_walk_all. 1696 For diamond shaped hierarchies we must mark the virtual bases, to 1697 avoid multiple walks. */ 1698 1699tree 1700dfs_walk_once (tree binfo, tree (*pre_fn) (tree, void *), 1701 tree (*post_fn) (tree, void *), void *data) 1702{ 1703 static int active = 0; /* We must not be called recursively. */ 1704 tree rval; 1705 1706 gcc_assert (pre_fn || post_fn); 1707 gcc_assert (!active); 1708 active++; 1709 1710 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo))) 1711 /* We are not diamond shaped, and therefore cannot encounter the 1712 same binfo twice. */ 1713 rval = dfs_walk_all (binfo, pre_fn, post_fn, data); 1714 else 1715 { 1716 rval = dfs_walk_once_r (binfo, pre_fn, post_fn, data); 1717 if (!BINFO_INHERITANCE_CHAIN (binfo)) 1718 { 1719 /* We are at the top of the hierarchy, and can use the 1720 CLASSTYPE_VBASECLASSES list for unmarking the virtual 1721 bases. */ 1722 vec<tree, va_gc> *vbases; 1723 unsigned ix; 1724 tree base_binfo; 1725 1726 for (vbases = CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)), ix = 0; 1727 vec_safe_iterate (vbases, ix, &base_binfo); ix++) 1728 BINFO_MARKED (base_binfo) = 0; 1729 } 1730 else 1731 dfs_unmark_r (binfo); 1732 } 1733 1734 active--; 1735 1736 return rval; 1737} 1738 1739/* Worker function for dfs_walk_once_accessible. Behaves like 1740 dfs_walk_once_r, except (a) FRIENDS_P is true if special 1741 access given by the current context should be considered, (b) ONCE 1742 indicates whether bases should be marked during traversal. */ 1743 1744static tree 1745dfs_walk_once_accessible_r (tree binfo, bool friends_p, bool once, 1746 tree (*pre_fn) (tree, void *), 1747 tree (*post_fn) (tree, void *), void *data) 1748{ 1749 tree rval = NULL_TREE; 1750 unsigned ix; 1751 tree base_binfo; 1752 1753 /* Call the pre-order walking function. */ 1754 if (pre_fn) 1755 { 1756 rval = pre_fn (binfo, data); 1757 if (rval) 1758 { 1759 if (rval == dfs_skip_bases) 1760 goto skip_bases; 1761 1762 return rval; 1763 } 1764 } 1765 1766 /* Find the next child binfo to walk. */ 1767 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++) 1768 { 1769 bool mark = once && BINFO_VIRTUAL_P (base_binfo); 1770 1771 if (mark && BINFO_MARKED (base_binfo)) 1772 continue; 1773 1774 /* If the base is inherited via private or protected 1775 inheritance, then we can't see it, unless we are a friend of 1776 the current binfo. */ 1777 if (BINFO_BASE_ACCESS (binfo, ix) != access_public_node) 1778 { 1779 tree scope; 1780 if (!friends_p) 1781 continue; 1782 scope = current_scope (); 1783 if (!scope 1784 || TREE_CODE (scope) == NAMESPACE_DECL 1785 || !is_friend (BINFO_TYPE (binfo), scope)) 1786 continue; 1787 } 1788 1789 if (mark) 1790 BINFO_MARKED (base_binfo) = 1; 1791 1792 rval = dfs_walk_once_accessible_r (base_binfo, friends_p, once, 1793 pre_fn, post_fn, data); 1794 if (rval) 1795 return rval; 1796 } 1797 1798 skip_bases: 1799 /* Call the post-order walking function. */ 1800 if (post_fn) 1801 { 1802 rval = post_fn (binfo, data); 1803 gcc_assert (rval != dfs_skip_bases); 1804 return rval; 1805 } 1806 1807 return NULL_TREE; 1808} 1809 1810/* Like dfs_walk_once except that only accessible bases are walked. 1811 FRIENDS_P indicates whether friendship of the local context 1812 should be considered when determining accessibility. */ 1813 1814static tree 1815dfs_walk_once_accessible (tree binfo, bool friends_p, 1816 tree (*pre_fn) (tree, void *), 1817 tree (*post_fn) (tree, void *), void *data) 1818{ 1819 bool diamond_shaped = CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo)); 1820 tree rval = dfs_walk_once_accessible_r (binfo, friends_p, diamond_shaped, 1821 pre_fn, post_fn, data); 1822 1823 if (diamond_shaped) 1824 { 1825 if (!BINFO_INHERITANCE_CHAIN (binfo)) 1826 { 1827 /* We are at the top of the hierarchy, and can use the 1828 CLASSTYPE_VBASECLASSES list for unmarking the virtual 1829 bases. */ 1830 vec<tree, va_gc> *vbases; 1831 unsigned ix; 1832 tree base_binfo; 1833 1834 for (vbases = CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)), ix = 0; 1835 vec_safe_iterate (vbases, ix, &base_binfo); ix++) 1836 BINFO_MARKED (base_binfo) = 0; 1837 } 1838 else 1839 dfs_unmark_r (binfo); 1840 } 1841 return rval; 1842} 1843 1844/* Check that virtual overrider OVERRIDER is acceptable for base function 1845 BASEFN. Issue diagnostic, and return zero, if unacceptable. */ 1846 1847static int 1848check_final_overrider (tree overrider, tree basefn) 1849{ 1850 tree over_type = TREE_TYPE (overrider); 1851 tree base_type = TREE_TYPE (basefn); 1852 tree over_return = TREE_TYPE (over_type); 1853 tree base_return = TREE_TYPE (base_type); 1854 tree over_throw, base_throw; 1855 1856 int fail = 0; 1857 1858 if (DECL_INVALID_OVERRIDER_P (overrider)) 1859 return 0; 1860 1861 if (same_type_p (base_return, over_return)) 1862 /* OK */; 1863 else if ((CLASS_TYPE_P (over_return) && CLASS_TYPE_P (base_return)) 1864 || (TREE_CODE (base_return) == TREE_CODE (over_return) 1865 && POINTER_TYPE_P (base_return))) 1866 { 1867 /* Potentially covariant. */ 1868 unsigned base_quals, over_quals; 1869 1870 fail = !POINTER_TYPE_P (base_return); 1871 if (!fail) 1872 { 1873 fail = cp_type_quals (base_return) != cp_type_quals (over_return); 1874 1875 base_return = TREE_TYPE (base_return); 1876 over_return = TREE_TYPE (over_return); 1877 } 1878 base_quals = cp_type_quals (base_return); 1879 over_quals = cp_type_quals (over_return); 1880 1881 if ((base_quals & over_quals) != over_quals) 1882 fail = 1; 1883 1884 if (CLASS_TYPE_P (base_return) && CLASS_TYPE_P (over_return)) 1885 { 1886 /* Strictly speaking, the standard requires the return type to be 1887 complete even if it only differs in cv-quals, but that seems 1888 like a bug in the wording. */ 1889 if (!same_type_ignoring_top_level_qualifiers_p (base_return, 1890 over_return)) 1891 { 1892 tree binfo = lookup_base (over_return, base_return, 1893 ba_check, NULL, tf_none); 1894 1895 if (!binfo || binfo == error_mark_node) 1896 fail = 1; 1897 } 1898 } 1899 else if (!pedantic 1900 && can_convert (TREE_TYPE (base_type), TREE_TYPE (over_type), 1901 tf_warning_or_error)) 1902 /* GNU extension, allow trivial pointer conversions such as 1903 converting to void *, or qualification conversion. */ 1904 { 1905 /* can_convert will permit user defined conversion from a 1906 (reference to) class type. We must reject them. */ 1907 over_return = non_reference (TREE_TYPE (over_type)); 1908 if (CLASS_TYPE_P (over_return)) 1909 fail = 2; 1910 else 1911 { 1912 warning (0, "deprecated covariant return type for %q+#D", 1913 overrider); 1914 warning (0, " overriding %q+#D", basefn); 1915 } 1916 } 1917 else 1918 fail = 2; 1919 } 1920 else 1921 fail = 2; 1922 if (!fail) 1923 /* OK */; 1924 else 1925 { 1926 if (fail == 1) 1927 { 1928 error ("invalid covariant return type for %q+#D", overrider); 1929 error (" overriding %q+#D", basefn); 1930 } 1931 else 1932 { 1933 error ("conflicting return type specified for %q+#D", overrider); 1934 error (" overriding %q+#D", basefn); 1935 } 1936 DECL_INVALID_OVERRIDER_P (overrider) = 1; 1937 return 0; 1938 } 1939 1940 /* Check throw specifier is at least as strict. */ 1941 maybe_instantiate_noexcept (basefn); 1942 maybe_instantiate_noexcept (overrider); 1943 base_throw = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (basefn)); 1944 over_throw = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (overrider)); 1945 1946 if (!comp_except_specs (base_throw, over_throw, ce_derived)) 1947 { 1948 error ("looser throw specifier for %q+#F", overrider); 1949 error (" overriding %q+#F", basefn); 1950 DECL_INVALID_OVERRIDER_P (overrider) = 1; 1951 return 0; 1952 } 1953 1954 /* Check for conflicting type attributes. */ 1955 if (!comp_type_attributes (over_type, base_type)) 1956 { 1957 error ("conflicting type attributes specified for %q+#D", overrider); 1958 error (" overriding %q+#D", basefn); 1959 DECL_INVALID_OVERRIDER_P (overrider) = 1; 1960 return 0; 1961 } 1962 1963 if (DECL_DELETED_FN (basefn) != DECL_DELETED_FN (overrider)) 1964 { 1965 if (DECL_DELETED_FN (overrider)) 1966 { 1967 error ("deleted function %q+D", overrider); 1968 error ("overriding non-deleted function %q+D", basefn); 1969 maybe_explain_implicit_delete (overrider); 1970 } 1971 else 1972 { 1973 error ("non-deleted function %q+D", overrider); 1974 error ("overriding deleted function %q+D", basefn); 1975 } 1976 return 0; 1977 } 1978 if (DECL_FINAL_P (basefn)) 1979 { 1980 error ("virtual function %q+D", overrider); 1981 error ("overriding final function %q+D", basefn); 1982 return 0; 1983 } 1984 return 1; 1985} 1986 1987/* Given a class TYPE, and a function decl FNDECL, look for 1988 virtual functions in TYPE's hierarchy which FNDECL overrides. 1989 We do not look in TYPE itself, only its bases. 1990 1991 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we 1992 find that it overrides anything. 1993 1994 We check that every function which is overridden, is correctly 1995 overridden. */ 1996 1997int 1998look_for_overrides (tree type, tree fndecl) 1999{ 2000 tree binfo = TYPE_BINFO (type); 2001 tree base_binfo; 2002 int ix; 2003 int found = 0; 2004 2005 /* A constructor for a class T does not override a function T 2006 in a base class. */ 2007 if (DECL_CONSTRUCTOR_P (fndecl)) 2008 return 0; 2009 2010 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++) 2011 { 2012 tree basetype = BINFO_TYPE (base_binfo); 2013 2014 if (TYPE_POLYMORPHIC_P (basetype)) 2015 found += look_for_overrides_r (basetype, fndecl); 2016 } 2017 return found; 2018} 2019 2020/* Look in TYPE for virtual functions with the same signature as 2021 FNDECL. */ 2022 2023tree 2024look_for_overrides_here (tree type, tree fndecl) 2025{ 2026 int ix; 2027 2028 /* If there are no methods in TYPE (meaning that only implicitly 2029 declared methods will ever be provided for TYPE), then there are 2030 no virtual functions. */ 2031 if (!CLASSTYPE_METHOD_VEC (type)) 2032 return NULL_TREE; 2033 2034 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fndecl)) 2035 ix = CLASSTYPE_DESTRUCTOR_SLOT; 2036 else 2037 ix = lookup_fnfields_1 (type, DECL_NAME (fndecl)); 2038 if (ix >= 0) 2039 { 2040 tree fns = (*CLASSTYPE_METHOD_VEC (type))[ix]; 2041 2042 for (; fns; fns = OVL_NEXT (fns)) 2043 { 2044 tree fn = OVL_CURRENT (fns); 2045 2046 if (!DECL_VIRTUAL_P (fn)) 2047 /* Not a virtual. */; 2048 else if (DECL_CONTEXT (fn) != type) 2049 /* Introduced with a using declaration. */; 2050 else if (DECL_STATIC_FUNCTION_P (fndecl)) 2051 { 2052 tree btypes = TYPE_ARG_TYPES (TREE_TYPE (fn)); 2053 tree dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); 2054 if (compparms (TREE_CHAIN (btypes), dtypes)) 2055 return fn; 2056 } 2057 else if (same_signature_p (fndecl, fn)) 2058 return fn; 2059 } 2060 } 2061 return NULL_TREE; 2062} 2063 2064/* Look in TYPE for virtual functions overridden by FNDECL. Check both 2065 TYPE itself and its bases. */ 2066 2067static int 2068look_for_overrides_r (tree type, tree fndecl) 2069{ 2070 tree fn = look_for_overrides_here (type, fndecl); 2071 if (fn) 2072 { 2073 if (DECL_STATIC_FUNCTION_P (fndecl)) 2074 { 2075 /* A static member function cannot match an inherited 2076 virtual member function. */ 2077 error ("%q+#D cannot be declared", fndecl); 2078 error (" since %q+#D declared in base class", fn); 2079 } 2080 else 2081 { 2082 /* It's definitely virtual, even if not explicitly set. */ 2083 DECL_VIRTUAL_P (fndecl) = 1; 2084 check_final_overrider (fndecl, fn); 2085 } 2086 return 1; 2087 } 2088 2089 /* We failed to find one declared in this class. Look in its bases. */ 2090 return look_for_overrides (type, fndecl); 2091} 2092 2093/* Called via dfs_walk from dfs_get_pure_virtuals. */ 2094 2095static tree 2096dfs_get_pure_virtuals (tree binfo, void *data) 2097{ 2098 tree type = (tree) data; 2099 2100 /* We're not interested in primary base classes; the derived class 2101 of which they are a primary base will contain the information we 2102 need. */ 2103 if (!BINFO_PRIMARY_P (binfo)) 2104 { 2105 tree virtuals; 2106 2107 for (virtuals = BINFO_VIRTUALS (binfo); 2108 virtuals; 2109 virtuals = TREE_CHAIN (virtuals)) 2110 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals))) 2111 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (type), BV_FN (virtuals)); 2112 } 2113 2114 return NULL_TREE; 2115} 2116 2117/* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */ 2118 2119void 2120get_pure_virtuals (tree type) 2121{ 2122 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there 2123 is going to be overridden. */ 2124 CLASSTYPE_PURE_VIRTUALS (type) = NULL; 2125 /* Now, run through all the bases which are not primary bases, and 2126 collect the pure virtual functions. We look at the vtable in 2127 each class to determine what pure virtual functions are present. 2128 (A primary base is not interesting because the derived class of 2129 which it is a primary base will contain vtable entries for the 2130 pure virtuals in the base class. */ 2131 dfs_walk_once (TYPE_BINFO (type), NULL, dfs_get_pure_virtuals, type); 2132} 2133 2134/* Debug info for C++ classes can get very large; try to avoid 2135 emitting it everywhere. 2136 2137 Note that this optimization wins even when the target supports 2138 BINCL (if only slightly), and reduces the amount of work for the 2139 linker. */ 2140 2141void 2142maybe_suppress_debug_info (tree t) 2143{ 2144 if (write_symbols == NO_DEBUG) 2145 return; 2146 2147 /* We might have set this earlier in cp_finish_decl. */ 2148 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 0; 2149 2150 /* Always emit the information for each class every time. */ 2151 if (flag_emit_class_debug_always) 2152 return; 2153 2154 /* If we already know how we're handling this class, handle debug info 2155 the same way. */ 2156 if (CLASSTYPE_INTERFACE_KNOWN (t)) 2157 { 2158 if (CLASSTYPE_INTERFACE_ONLY (t)) 2159 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1; 2160 /* else don't set it. */ 2161 } 2162 /* If the class has a vtable, write out the debug info along with 2163 the vtable. */ 2164 else if (TYPE_CONTAINS_VPTR_P (t)) 2165 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1; 2166 2167 /* Otherwise, just emit the debug info normally. */ 2168} 2169 2170/* Note that we want debugging information for a base class of a class 2171 whose vtable is being emitted. Normally, this would happen because 2172 calling the constructor for a derived class implies calling the 2173 constructors for all bases, which involve initializing the 2174 appropriate vptr with the vtable for the base class; but in the 2175 presence of optimization, this initialization may be optimized 2176 away, so we tell finish_vtable_vardecl that we want the debugging 2177 information anyway. */ 2178 2179static tree 2180dfs_debug_mark (tree binfo, void * /*data*/) 2181{ 2182 tree t = BINFO_TYPE (binfo); 2183 2184 if (CLASSTYPE_DEBUG_REQUESTED (t)) 2185 return dfs_skip_bases; 2186 2187 CLASSTYPE_DEBUG_REQUESTED (t) = 1; 2188 2189 return NULL_TREE; 2190} 2191 2192/* Write out the debugging information for TYPE, whose vtable is being 2193 emitted. Also walk through our bases and note that we want to 2194 write out information for them. This avoids the problem of not 2195 writing any debug info for intermediate basetypes whose 2196 constructors, and thus the references to their vtables, and thus 2197 the vtables themselves, were optimized away. */ 2198 2199void 2200note_debug_info_needed (tree type) 2201{ 2202 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type))) 2203 { 2204 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)) = 0; 2205 rest_of_type_compilation (type, toplevel_bindings_p ()); 2206 } 2207 2208 dfs_walk_all (TYPE_BINFO (type), dfs_debug_mark, NULL, 0); 2209} 2210 2211void 2212print_search_statistics (void) 2213{ 2214 if (! GATHER_STATISTICS) 2215 { 2216 fprintf (stderr, "no search statistics\n"); 2217 return; 2218 } 2219 2220 fprintf (stderr, "%d fields searched in %d[%d] calls to lookup_field[_1]\n", 2221 n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1); 2222 fprintf (stderr, "%d fnfields searched in %d calls to lookup_fnfields\n", 2223 n_outer_fields_searched, n_calls_lookup_fnfields); 2224 fprintf (stderr, "%d calls to get_base_type\n", n_calls_get_base_type); 2225} 2226 2227void 2228reinit_search_statistics (void) 2229{ 2230 n_fields_searched = 0; 2231 n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0; 2232 n_calls_lookup_fnfields = 0, n_calls_lookup_fnfields_1 = 0; 2233 n_calls_get_base_type = 0; 2234 n_outer_fields_searched = 0; 2235 n_contexts_saved = 0; 2236} 2237 2238/* Helper for lookup_conversions_r. TO_TYPE is the type converted to 2239 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if 2240 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual 2241 bases have been encountered already in the tree walk. PARENT_CONVS 2242 is the list of lists of conversion functions that could hide CONV 2243 and OTHER_CONVS is the list of lists of conversion functions that 2244 could hide or be hidden by CONV, should virtualness be involved in 2245 the hierarchy. Merely checking the conversion op's name is not 2246 enough because two conversion operators to the same type can have 2247 different names. Return nonzero if we are visible. */ 2248 2249static int 2250check_hidden_convs (tree binfo, int virtual_depth, int virtualness, 2251 tree to_type, tree parent_convs, tree other_convs) 2252{ 2253 tree level, probe; 2254 2255 /* See if we are hidden by a parent conversion. */ 2256 for (level = parent_convs; level; level = TREE_CHAIN (level)) 2257 for (probe = TREE_VALUE (level); probe; probe = TREE_CHAIN (probe)) 2258 if (same_type_p (to_type, TREE_TYPE (probe))) 2259 return 0; 2260 2261 if (virtual_depth || virtualness) 2262 { 2263 /* In a virtual hierarchy, we could be hidden, or could hide a 2264 conversion function on the other_convs list. */ 2265 for (level = other_convs; level; level = TREE_CHAIN (level)) 2266 { 2267 int we_hide_them; 2268 int they_hide_us; 2269 tree *prev, other; 2270 2271 if (!(virtual_depth || TREE_STATIC (level))) 2272 /* Neither is morally virtual, so cannot hide each other. */ 2273 continue; 2274 2275 if (!TREE_VALUE (level)) 2276 /* They evaporated away already. */ 2277 continue; 2278 2279 they_hide_us = (virtual_depth 2280 && original_binfo (binfo, TREE_PURPOSE (level))); 2281 we_hide_them = (!they_hide_us && TREE_STATIC (level) 2282 && original_binfo (TREE_PURPOSE (level), binfo)); 2283 2284 if (!(we_hide_them || they_hide_us)) 2285 /* Neither is within the other, so no hiding can occur. */ 2286 continue; 2287 2288 for (prev = &TREE_VALUE (level), other = *prev; other;) 2289 { 2290 if (same_type_p (to_type, TREE_TYPE (other))) 2291 { 2292 if (they_hide_us) 2293 /* We are hidden. */ 2294 return 0; 2295 2296 if (we_hide_them) 2297 { 2298 /* We hide the other one. */ 2299 other = TREE_CHAIN (other); 2300 *prev = other; 2301 continue; 2302 } 2303 } 2304 prev = &TREE_CHAIN (other); 2305 other = *prev; 2306 } 2307 } 2308 } 2309 return 1; 2310} 2311 2312/* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists 2313 of conversion functions, the first slot will be for the current 2314 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists 2315 of conversion functions from children of the current binfo, 2316 concatenated with conversions from elsewhere in the hierarchy -- 2317 that list begins with OTHER_CONVS. Return a single list of lists 2318 containing only conversions from the current binfo and its 2319 children. */ 2320 2321static tree 2322split_conversions (tree my_convs, tree parent_convs, 2323 tree child_convs, tree other_convs) 2324{ 2325 tree t; 2326 tree prev; 2327 2328 /* Remove the original other_convs portion from child_convs. */ 2329 for (prev = NULL, t = child_convs; 2330 t != other_convs; prev = t, t = TREE_CHAIN (t)) 2331 continue; 2332 2333 if (prev) 2334 TREE_CHAIN (prev) = NULL_TREE; 2335 else 2336 child_convs = NULL_TREE; 2337 2338 /* Attach the child convs to any we had at this level. */ 2339 if (my_convs) 2340 { 2341 my_convs = parent_convs; 2342 TREE_CHAIN (my_convs) = child_convs; 2343 } 2344 else 2345 my_convs = child_convs; 2346 2347 return my_convs; 2348} 2349 2350/* Worker for lookup_conversions. Lookup conversion functions in 2351 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in 2352 a morally virtual base, and VIRTUALNESS is nonzero, if we've 2353 encountered virtual bases already in the tree walk. PARENT_CONVS & 2354 PARENT_TPL_CONVS are lists of list of conversions within parent 2355 binfos. OTHER_CONVS and OTHER_TPL_CONVS are conversions found 2356 elsewhere in the tree. Return the conversions found within this 2357 portion of the graph in CONVS and TPL_CONVS. Return nonzero is we 2358 encountered virtualness. We keep template and non-template 2359 conversions separate, to avoid unnecessary type comparisons. 2360 2361 The located conversion functions are held in lists of lists. The 2362 TREE_VALUE of the outer list is the list of conversion functions 2363 found in a particular binfo. The TREE_PURPOSE of both the outer 2364 and inner lists is the binfo at which those conversions were 2365 found. TREE_STATIC is set for those lists within of morally 2366 virtual binfos. The TREE_VALUE of the inner list is the conversion 2367 function or overload itself. The TREE_TYPE of each inner list node 2368 is the converted-to type. */ 2369 2370static int 2371lookup_conversions_r (tree binfo, 2372 int virtual_depth, int virtualness, 2373 tree parent_convs, tree parent_tpl_convs, 2374 tree other_convs, tree other_tpl_convs, 2375 tree *convs, tree *tpl_convs) 2376{ 2377 int my_virtualness = 0; 2378 tree my_convs = NULL_TREE; 2379 tree my_tpl_convs = NULL_TREE; 2380 tree child_convs = NULL_TREE; 2381 tree child_tpl_convs = NULL_TREE; 2382 unsigned i; 2383 tree base_binfo; 2384 vec<tree, va_gc> *method_vec = CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo)); 2385 tree conv; 2386 2387 /* If we have no conversion operators, then don't look. */ 2388 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo))) 2389 { 2390 *convs = *tpl_convs = NULL_TREE; 2391 2392 return 0; 2393 } 2394 2395 if (BINFO_VIRTUAL_P (binfo)) 2396 virtual_depth++; 2397 2398 /* First, locate the unhidden ones at this level. */ 2399 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT; 2400 vec_safe_iterate (method_vec, i, &conv); 2401 ++i) 2402 { 2403 tree cur = OVL_CURRENT (conv); 2404 2405 if (!DECL_CONV_FN_P (cur)) 2406 break; 2407 2408 if (TREE_CODE (cur) == TEMPLATE_DECL) 2409 { 2410 /* Only template conversions can be overloaded, and we must 2411 flatten them out and check each one individually. */ 2412 tree tpls; 2413 2414 for (tpls = conv; tpls; tpls = OVL_NEXT (tpls)) 2415 { 2416 tree tpl = OVL_CURRENT (tpls); 2417 tree type = DECL_CONV_FN_TYPE (tpl); 2418 2419 if (check_hidden_convs (binfo, virtual_depth, virtualness, 2420 type, parent_tpl_convs, other_tpl_convs)) 2421 { 2422 my_tpl_convs = tree_cons (binfo, tpl, my_tpl_convs); 2423 TREE_TYPE (my_tpl_convs) = type; 2424 if (virtual_depth) 2425 { 2426 TREE_STATIC (my_tpl_convs) = 1; 2427 my_virtualness = 1; 2428 } 2429 } 2430 } 2431 } 2432 else 2433 { 2434 tree name = DECL_NAME (cur); 2435 2436 if (!IDENTIFIER_MARKED (name)) 2437 { 2438 tree type = DECL_CONV_FN_TYPE (cur); 2439 if (type_uses_auto (type)) 2440 { 2441 mark_used (cur); 2442 type = DECL_CONV_FN_TYPE (cur); 2443 } 2444 2445 if (check_hidden_convs (binfo, virtual_depth, virtualness, 2446 type, parent_convs, other_convs)) 2447 { 2448 my_convs = tree_cons (binfo, conv, my_convs); 2449 TREE_TYPE (my_convs) = type; 2450 if (virtual_depth) 2451 { 2452 TREE_STATIC (my_convs) = 1; 2453 my_virtualness = 1; 2454 } 2455 IDENTIFIER_MARKED (name) = 1; 2456 } 2457 } 2458 } 2459 } 2460 2461 if (my_convs) 2462 { 2463 parent_convs = tree_cons (binfo, my_convs, parent_convs); 2464 if (virtual_depth) 2465 TREE_STATIC (parent_convs) = 1; 2466 } 2467 2468 if (my_tpl_convs) 2469 { 2470 parent_tpl_convs = tree_cons (binfo, my_tpl_convs, parent_tpl_convs); 2471 if (virtual_depth) 2472 TREE_STATIC (parent_tpl_convs) = 1; 2473 } 2474 2475 child_convs = other_convs; 2476 child_tpl_convs = other_tpl_convs; 2477 2478 /* Now iterate over each base, looking for more conversions. */ 2479 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 2480 { 2481 tree base_convs, base_tpl_convs; 2482 unsigned base_virtualness; 2483 2484 base_virtualness = lookup_conversions_r (base_binfo, 2485 virtual_depth, virtualness, 2486 parent_convs, parent_tpl_convs, 2487 child_convs, child_tpl_convs, 2488 &base_convs, &base_tpl_convs); 2489 if (base_virtualness) 2490 my_virtualness = virtualness = 1; 2491 child_convs = chainon (base_convs, child_convs); 2492 child_tpl_convs = chainon (base_tpl_convs, child_tpl_convs); 2493 } 2494 2495 /* Unmark the conversions found at this level */ 2496 for (conv = my_convs; conv; conv = TREE_CHAIN (conv)) 2497 IDENTIFIER_MARKED (DECL_NAME (OVL_CURRENT (TREE_VALUE (conv)))) = 0; 2498 2499 *convs = split_conversions (my_convs, parent_convs, 2500 child_convs, other_convs); 2501 *tpl_convs = split_conversions (my_tpl_convs, parent_tpl_convs, 2502 child_tpl_convs, other_tpl_convs); 2503 2504 return my_virtualness; 2505} 2506 2507/* Return a TREE_LIST containing all the non-hidden user-defined 2508 conversion functions for TYPE (and its base-classes). The 2509 TREE_VALUE of each node is the FUNCTION_DECL of the conversion 2510 function. The TREE_PURPOSE is the BINFO from which the conversion 2511 functions in this node were selected. This function is effectively 2512 performing a set of member lookups as lookup_fnfield does, but 2513 using the type being converted to as the unique key, rather than the 2514 field name. */ 2515 2516tree 2517lookup_conversions (tree type) 2518{ 2519 tree convs, tpl_convs; 2520 tree list = NULL_TREE; 2521 2522 complete_type (type); 2523 if (!TYPE_BINFO (type)) 2524 return NULL_TREE; 2525 2526 lookup_conversions_r (TYPE_BINFO (type), 0, 0, 2527 NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE, 2528 &convs, &tpl_convs); 2529 2530 /* Flatten the list-of-lists */ 2531 for (; convs; convs = TREE_CHAIN (convs)) 2532 { 2533 tree probe, next; 2534 2535 for (probe = TREE_VALUE (convs); probe; probe = next) 2536 { 2537 next = TREE_CHAIN (probe); 2538 2539 TREE_CHAIN (probe) = list; 2540 list = probe; 2541 } 2542 } 2543 2544 for (; tpl_convs; tpl_convs = TREE_CHAIN (tpl_convs)) 2545 { 2546 tree probe, next; 2547 2548 for (probe = TREE_VALUE (tpl_convs); probe; probe = next) 2549 { 2550 next = TREE_CHAIN (probe); 2551 2552 TREE_CHAIN (probe) = list; 2553 list = probe; 2554 } 2555 } 2556 2557 return list; 2558} 2559 2560/* Returns the binfo of the first direct or indirect virtual base derived 2561 from BINFO, or NULL if binfo is not via virtual. */ 2562 2563tree 2564binfo_from_vbase (tree binfo) 2565{ 2566 for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo)) 2567 { 2568 if (BINFO_VIRTUAL_P (binfo)) 2569 return binfo; 2570 } 2571 return NULL_TREE; 2572} 2573 2574/* Returns the binfo of the first direct or indirect virtual base derived 2575 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not 2576 via virtual. */ 2577 2578tree 2579binfo_via_virtual (tree binfo, tree limit) 2580{ 2581 if (limit && !CLASSTYPE_VBASECLASSES (limit)) 2582 /* LIMIT has no virtual bases, so BINFO cannot be via one. */ 2583 return NULL_TREE; 2584 2585 for (; binfo && !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), limit); 2586 binfo = BINFO_INHERITANCE_CHAIN (binfo)) 2587 { 2588 if (BINFO_VIRTUAL_P (binfo)) 2589 return binfo; 2590 } 2591 return NULL_TREE; 2592} 2593 2594/* BINFO is a base binfo in the complete type BINFO_TYPE (HERE). 2595 Find the equivalent binfo within whatever graph HERE is located. 2596 This is the inverse of original_binfo. */ 2597 2598tree 2599copied_binfo (tree binfo, tree here) 2600{ 2601 tree result = NULL_TREE; 2602 2603 if (BINFO_VIRTUAL_P (binfo)) 2604 { 2605 tree t; 2606 2607 for (t = here; BINFO_INHERITANCE_CHAIN (t); 2608 t = BINFO_INHERITANCE_CHAIN (t)) 2609 continue; 2610 2611 result = binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (t)); 2612 } 2613 else if (BINFO_INHERITANCE_CHAIN (binfo)) 2614 { 2615 tree cbinfo; 2616 tree base_binfo; 2617 int ix; 2618 2619 cbinfo = copied_binfo (BINFO_INHERITANCE_CHAIN (binfo), here); 2620 for (ix = 0; BINFO_BASE_ITERATE (cbinfo, ix, base_binfo); ix++) 2621 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), BINFO_TYPE (binfo))) 2622 { 2623 result = base_binfo; 2624 break; 2625 } 2626 } 2627 else 2628 { 2629 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here), BINFO_TYPE (binfo))); 2630 result = here; 2631 } 2632 2633 gcc_assert (result); 2634 return result; 2635} 2636 2637tree 2638binfo_for_vbase (tree base, tree t) 2639{ 2640 unsigned ix; 2641 tree binfo; 2642 vec<tree, va_gc> *vbases; 2643 2644 for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0; 2645 vec_safe_iterate (vbases, ix, &binfo); ix++) 2646 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), base)) 2647 return binfo; 2648 return NULL; 2649} 2650 2651/* BINFO is some base binfo of HERE, within some other 2652 hierarchy. Return the equivalent binfo, but in the hierarchy 2653 dominated by HERE. This is the inverse of copied_binfo. If BINFO 2654 is not a base binfo of HERE, returns NULL_TREE. */ 2655 2656tree 2657original_binfo (tree binfo, tree here) 2658{ 2659 tree result = NULL; 2660 2661 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (here))) 2662 result = here; 2663 else if (BINFO_VIRTUAL_P (binfo)) 2664 result = (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here)) 2665 ? binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (here)) 2666 : NULL_TREE); 2667 else if (BINFO_INHERITANCE_CHAIN (binfo)) 2668 { 2669 tree base_binfos; 2670 2671 base_binfos = original_binfo (BINFO_INHERITANCE_CHAIN (binfo), here); 2672 if (base_binfos) 2673 { 2674 int ix; 2675 tree base_binfo; 2676 2677 for (ix = 0; (base_binfo = BINFO_BASE_BINFO (base_binfos, ix)); ix++) 2678 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), 2679 BINFO_TYPE (binfo))) 2680 { 2681 result = base_binfo; 2682 break; 2683 } 2684 } 2685 } 2686 2687 return result; 2688} 2689 2690