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