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