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