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
5 Free Software Foundation, Inc.
6 Contributed by Michael Tiemann (tiemann@cygnus.com)
8 This file is part of GCC.
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)
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.
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/>. */
24 /* High-level class interface. */
28 #include "coretypes.h"
39 static int is_subobject_of_p (tree, tree);
40 static tree dfs_lookup_base (tree, void *);
41 static tree dfs_dcast_hint_pre (tree, void *);
42 static tree dfs_dcast_hint_post (tree, void *);
43 static tree dfs_debug_mark (tree, void *);
44 static tree dfs_walk_once_r (tree, tree (*pre_fn) (tree, void *),
45 tree (*post_fn) (tree, void *), void *data);
46 static void dfs_unmark_r (tree);
47 static int check_hidden_convs (tree, int, int, tree, tree, tree);
48 static tree split_conversions (tree, tree, tree, tree);
49 static int lookup_conversions_r (tree, int, int,
50 tree, tree, tree, tree, tree *, tree *);
51 static int look_for_overrides_r (tree, tree);
52 static tree lookup_field_r (tree, void *);
53 static tree dfs_accessible_post (tree, void *);
54 static tree dfs_walk_once_accessible_r (tree, bool, bool,
55 tree (*pre_fn) (tree, void *),
56 tree (*post_fn) (tree, void *),
58 static tree dfs_walk_once_accessible (tree, bool,
59 tree (*pre_fn) (tree, void *),
60 tree (*post_fn) (tree, void *),
62 static tree dfs_access_in_type (tree, void *);
63 static access_kind access_in_type (tree, tree);
64 static int protected_accessible_p (tree, tree, tree);
65 static int friend_accessible_p (tree, tree, tree);
66 static tree dfs_get_pure_virtuals (tree, void *);
69 /* Variables for gathering statistics. */
70 #ifdef GATHER_STATISTICS
71 static int n_fields_searched;
72 static int n_calls_lookup_field, n_calls_lookup_field_1;
73 static int n_calls_lookup_fnfields, n_calls_lookup_fnfields_1;
74 static int n_calls_get_base_type;
75 static int n_outer_fields_searched;
76 static int n_contexts_saved;
77 #endif /* GATHER_STATISTICS */
80 /* Data for lookup_base and its workers. */
82 struct lookup_base_data_s
84 tree t; /* type being searched. */
85 tree base; /* The base type we're looking for. */
86 tree binfo; /* Found binfo. */
87 bool via_virtual; /* Found via a virtual path. */
88 bool ambiguous; /* Found multiply ambiguous */
89 bool repeated_base; /* Whether there are repeated bases in the
91 bool want_any; /* Whether we want any matching binfo. */
94 /* Worker function for lookup_base. See if we've found the desired
95 base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
98 dfs_lookup_base (tree binfo, void *data_)
100 struct lookup_base_data_s *data = (struct lookup_base_data_s *) data_;
102 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->base))
108 = binfo_via_virtual (data->binfo, data->t) != NULL_TREE;
110 if (!data->repeated_base)
111 /* If there are no repeated bases, we can stop now. */
114 if (data->want_any && !data->via_virtual)
115 /* If this is a non-virtual base, then we can't do
119 return dfs_skip_bases;
123 gcc_assert (binfo != data->binfo);
125 /* We've found more than one matching binfo. */
128 /* This is immediately ambiguous. */
129 data->binfo = NULL_TREE;
130 data->ambiguous = true;
131 return error_mark_node;
134 /* Prefer one via a non-virtual path. */
135 if (!binfo_via_virtual (binfo, data->t))
138 data->via_virtual = false;
142 /* There must be repeated bases, otherwise we'd have stopped
143 on the first base we found. */
144 return dfs_skip_bases;
151 /* Returns true if type BASE is accessible in T. (BASE is known to be
152 a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
153 true, consider any special access of the current scope, or access
154 bestowed by friendship. */
157 accessible_base_p (tree t, tree base, bool consider_local_p)
161 /* [class.access.base]
163 A base class is said to be accessible if an invented public
164 member of the base class is accessible.
166 If BASE is a non-proper base, this condition is trivially
168 if (same_type_p (t, base))
170 /* Rather than inventing a public member, we use the implicit
171 public typedef created in the scope of every class. */
172 decl = TYPE_FIELDS (base);
173 while (!DECL_SELF_REFERENCE_P (decl))
174 decl = TREE_CHAIN (decl);
175 while (ANON_AGGR_TYPE_P (t))
176 t = TYPE_CONTEXT (t);
177 return accessible_p (t, decl, consider_local_p);
180 /* Lookup BASE in the hierarchy dominated by T. Do access checking as
181 ACCESS specifies. Return the binfo we discover. If KIND_PTR is
182 non-NULL, fill with information about what kind of base we
185 If the base is inaccessible, or ambiguous, and the ba_quiet bit is
186 not set in ACCESS, then an error is issued and error_mark_node is
187 returned. If the ba_quiet bit is set, then no error is issued and
188 NULL_TREE is returned. */
191 lookup_base (tree t, tree base, base_access access, base_kind *kind_ptr)
197 if (t == error_mark_node || base == error_mark_node)
200 *kind_ptr = bk_not_base;
201 return error_mark_node;
203 gcc_assert (TYPE_P (base));
212 t = complete_type (TYPE_MAIN_VARIANT (t));
213 t_binfo = TYPE_BINFO (t);
216 base = TYPE_MAIN_VARIANT (base);
218 /* If BASE is incomplete, it can't be a base of T--and instantiating it
219 might cause an error. */
220 if (t_binfo && CLASS_TYPE_P (base)
221 && (COMPLETE_TYPE_P (base) || TYPE_BEING_DEFINED (base)))
223 struct lookup_base_data_s data;
227 data.binfo = NULL_TREE;
228 data.ambiguous = data.via_virtual = false;
229 data.repeated_base = CLASSTYPE_REPEATED_BASE_P (t);
230 data.want_any = access == ba_any;
232 dfs_walk_once (t_binfo, dfs_lookup_base, NULL, &data);
236 bk = data.ambiguous ? bk_ambig : bk_not_base;
237 else if (binfo == t_binfo)
239 else if (data.via_virtual)
250 /* Check that the base is unambiguous and accessible. */
251 if (access != ba_any)
258 if (!(access & ba_quiet))
260 error ("%qT is an ambiguous base of %qT", base, t);
261 binfo = error_mark_node;
266 if ((access & ba_check_bit)
267 /* If BASE is incomplete, then BASE and TYPE are probably
268 the same, in which case BASE is accessible. If they
269 are not the same, then TYPE is invalid. In that case,
270 there's no need to issue another error here, and
271 there's no implicit typedef to use in the code that
272 follows, so we skip the check. */
273 && COMPLETE_TYPE_P (base)
274 && !accessible_base_p (t, base, !(access & ba_ignore_scope)))
276 if (!(access & ba_quiet))
278 error ("%qT is an inaccessible base of %qT", base, t);
279 binfo = error_mark_node;
283 bk = bk_inaccessible;
294 /* Data for dcast_base_hint walker. */
298 tree subtype; /* The base type we're looking for. */
299 int virt_depth; /* Number of virtual bases encountered from most
301 tree offset; /* Best hint offset discovered so far. */
302 bool repeated_base; /* Whether there are repeated bases in the
306 /* Worker for dcast_base_hint. Search for the base type being cast
310 dfs_dcast_hint_pre (tree binfo, void *data_)
312 struct dcast_data_s *data = (struct dcast_data_s *) data_;
314 if (BINFO_VIRTUAL_P (binfo))
317 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->subtype))
319 if (data->virt_depth)
321 data->offset = ssize_int (-1);
325 data->offset = ssize_int (-3);
327 data->offset = BINFO_OFFSET (binfo);
329 return data->repeated_base ? dfs_skip_bases : data->offset;
335 /* Worker for dcast_base_hint. Track the virtual depth. */
338 dfs_dcast_hint_post (tree binfo, void *data_)
340 struct dcast_data_s *data = (struct dcast_data_s *) data_;
342 if (BINFO_VIRTUAL_P (binfo))
348 /* The dynamic cast runtime needs a hint about how the static SUBTYPE type
349 started from is related to the required TARGET type, in order to optimize
350 the inheritance graph search. This information is independent of the
351 current context, and ignores private paths, hence get_base_distance is
352 inappropriate. Return a TREE specifying the base offset, BOFF.
353 BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
354 and there are no public virtual SUBTYPE bases.
355 BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
356 BOFF == -2, SUBTYPE is not a public base.
357 BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
360 dcast_base_hint (tree subtype, tree target)
362 struct dcast_data_s data;
364 data.subtype = subtype;
366 data.offset = NULL_TREE;
367 data.repeated_base = CLASSTYPE_REPEATED_BASE_P (target);
369 dfs_walk_once_accessible (TYPE_BINFO (target), /*friends=*/false,
370 dfs_dcast_hint_pre, dfs_dcast_hint_post, &data);
371 return data.offset ? data.offset : ssize_int (-2);
374 /* Search for a member with name NAME in a multiple inheritance
375 lattice specified by TYPE. If it does not exist, return NULL_TREE.
376 If the member is ambiguously referenced, return `error_mark_node'.
377 Otherwise, return a DECL with the indicated name. If WANT_TYPE is
378 true, type declarations are preferred. */
380 /* Do a 1-level search for NAME as a member of TYPE. The caller must
381 figure out whether it can access this field. (Since it is only one
382 level, this is reasonable.) */
385 lookup_field_1 (tree type, tree name, bool want_type)
389 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
390 || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
391 || TREE_CODE (type) == TYPENAME_TYPE)
392 /* The TYPE_FIELDS of a TEMPLATE_TYPE_PARM and
393 BOUND_TEMPLATE_TEMPLATE_PARM are not fields at all;
394 instead TYPE_FIELDS is the TEMPLATE_PARM_INDEX. (Miraculously,
395 the code often worked even when we treated the index as a list
397 The TYPE_FIELDS of TYPENAME_TYPE is its TYPENAME_TYPE_FULLNAME. */
400 if (CLASSTYPE_SORTED_FIELDS (type))
402 tree *fields = &CLASSTYPE_SORTED_FIELDS (type)->elts[0];
403 int lo = 0, hi = CLASSTYPE_SORTED_FIELDS (type)->len;
410 #ifdef GATHER_STATISTICS
412 #endif /* GATHER_STATISTICS */
414 if (DECL_NAME (fields[i]) > name)
416 else if (DECL_NAME (fields[i]) < name)
422 /* We might have a nested class and a field with the
423 same name; we sorted them appropriately via
424 field_decl_cmp, so just look for the first or last
425 field with this name. */
430 while (i >= lo && DECL_NAME (fields[i]) == name);
431 if (TREE_CODE (field) != TYPE_DECL
432 && !DECL_CLASS_TEMPLATE_P (field))
439 while (i < hi && DECL_NAME (fields[i]) == name);
447 field = TYPE_FIELDS (type);
449 #ifdef GATHER_STATISTICS
450 n_calls_lookup_field_1++;
451 #endif /* GATHER_STATISTICS */
452 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
454 #ifdef GATHER_STATISTICS
456 #endif /* GATHER_STATISTICS */
457 gcc_assert (DECL_P (field));
458 if (DECL_NAME (field) == NULL_TREE
459 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
461 tree temp = lookup_field_1 (TREE_TYPE (field), name, want_type);
465 if (TREE_CODE (field) == USING_DECL)
467 /* We generally treat class-scope using-declarations as
468 ARM-style access specifications, because support for the
469 ISO semantics has not been implemented. So, in general,
470 there's no reason to return a USING_DECL, and the rest of
471 the compiler cannot handle that. Once the class is
472 defined, USING_DECLs are purged from TYPE_FIELDS; see
473 handle_using_decl. However, we make special efforts to
474 make using-declarations in class templates and class
475 template partial specializations work correctly. */
476 if (!DECL_DEPENDENT_P (field))
480 if (DECL_NAME (field) == name
482 || TREE_CODE (field) == TYPE_DECL
483 || DECL_CLASS_TEMPLATE_P (field)))
487 if (name == vptr_identifier)
489 /* Give the user what s/he thinks s/he wants. */
490 if (TYPE_POLYMORPHIC_P (type))
491 return TYPE_VFIELD (type);
496 /* Return the FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, or
497 NAMESPACE_DECL corresponding to the innermost non-block scope. */
502 /* There are a number of cases we need to be aware of here:
503 current_class_type current_function_decl
510 Those last two make life interesting. If we're in a function which is
511 itself inside a class, we need decls to go into the fn's decls (our
512 second case below). But if we're in a class and the class itself is
513 inside a function, we need decls to go into the decls for the class. To
514 achieve this last goal, we must see if, when both current_class_ptr and
515 current_function_decl are set, the class was declared inside that
516 function. If so, we know to put the decls into the class's scope. */
517 if (current_function_decl && current_class_type
518 && ((DECL_FUNCTION_MEMBER_P (current_function_decl)
519 && same_type_p (DECL_CONTEXT (current_function_decl),
521 || (DECL_FRIEND_CONTEXT (current_function_decl)
522 && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl),
523 current_class_type))))
524 return current_function_decl;
525 if (current_class_type)
526 return current_class_type;
527 if (current_function_decl)
528 return current_function_decl;
529 return current_namespace;
532 /* Returns nonzero if we are currently in a function scope. Note
533 that this function returns zero if we are within a local class, but
534 not within a member function body of the local class. */
537 at_function_scope_p (void)
539 tree cs = current_scope ();
540 return cs && TREE_CODE (cs) == FUNCTION_DECL;
543 /* Returns true if the innermost active scope is a class scope. */
546 at_class_scope_p (void)
548 tree cs = current_scope ();
549 return cs && TYPE_P (cs);
552 /* Returns true if the innermost active scope is a namespace scope. */
555 at_namespace_scope_p (void)
557 tree cs = current_scope ();
558 return cs && TREE_CODE (cs) == NAMESPACE_DECL;
561 /* Return the scope of DECL, as appropriate when doing name-lookup. */
564 context_for_name_lookup (tree decl)
568 For the purposes of name lookup, after the anonymous union
569 definition, the members of the anonymous union are considered to
570 have been defined in the scope in which the anonymous union is
572 tree context = DECL_CONTEXT (decl);
574 while (context && TYPE_P (context) && ANON_AGGR_TYPE_P (context))
575 context = TYPE_CONTEXT (context);
577 context = global_namespace;
582 /* The accessibility routines use BINFO_ACCESS for scratch space
583 during the computation of the accessibility of some declaration. */
585 #define BINFO_ACCESS(NODE) \
586 ((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE)))
588 /* Set the access associated with NODE to ACCESS. */
590 #define SET_BINFO_ACCESS(NODE, ACCESS) \
591 ((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \
592 (TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0))
594 /* Called from access_in_type via dfs_walk. Calculate the access to
595 DATA (which is really a DECL) in BINFO. */
598 dfs_access_in_type (tree binfo, void *data)
600 tree decl = (tree) data;
601 tree type = BINFO_TYPE (binfo);
602 access_kind access = ak_none;
604 if (context_for_name_lookup (decl) == type)
606 /* If we have descended to the scope of DECL, just note the
607 appropriate access. */
608 if (TREE_PRIVATE (decl))
610 else if (TREE_PROTECTED (decl))
611 access = ak_protected;
617 /* First, check for an access-declaration that gives us more
618 access to the DECL. The CONST_DECL for an enumeration
619 constant will not have DECL_LANG_SPECIFIC, and thus no
621 if (DECL_LANG_SPECIFIC (decl) && !DECL_DISCRIMINATOR_P (decl))
623 tree decl_access = purpose_member (type, DECL_ACCESS (decl));
627 decl_access = TREE_VALUE (decl_access);
629 if (decl_access == access_public_node)
631 else if (decl_access == access_protected_node)
632 access = ak_protected;
633 else if (decl_access == access_private_node)
644 VEC(tree,gc) *accesses;
646 /* Otherwise, scan our baseclasses, and pick the most favorable
648 accesses = BINFO_BASE_ACCESSES (binfo);
649 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
651 tree base_access = VEC_index (tree, accesses, i);
652 access_kind base_access_now = BINFO_ACCESS (base_binfo);
654 if (base_access_now == ak_none || base_access_now == ak_private)
655 /* If it was not accessible in the base, or only
656 accessible as a private member, we can't access it
658 base_access_now = ak_none;
659 else if (base_access == access_protected_node)
660 /* Public and protected members in the base become
662 base_access_now = ak_protected;
663 else if (base_access == access_private_node)
664 /* Public and protected members in the base become
666 base_access_now = ak_private;
668 /* See if the new access, via this base, gives more
669 access than our previous best access. */
670 if (base_access_now != ak_none
671 && (access == ak_none || base_access_now < access))
673 access = base_access_now;
675 /* If the new access is public, we can't do better. */
676 if (access == ak_public)
683 /* Note the access to DECL in TYPE. */
684 SET_BINFO_ACCESS (binfo, access);
689 /* Return the access to DECL in TYPE. */
692 access_in_type (tree type, tree decl)
694 tree binfo = TYPE_BINFO (type);
696 /* We must take into account
700 If a name can be reached by several paths through a multiple
701 inheritance graph, the access is that of the path that gives
704 The algorithm we use is to make a post-order depth-first traversal
705 of the base-class hierarchy. As we come up the tree, we annotate
706 each node with the most lenient access. */
707 dfs_walk_once (binfo, NULL, dfs_access_in_type, decl);
709 return BINFO_ACCESS (binfo);
712 /* Returns nonzero if it is OK to access DECL through an object
713 indicated by BINFO in the context of DERIVED. */
716 protected_accessible_p (tree decl, tree derived, tree binfo)
720 /* We're checking this clause from [class.access.base]
722 m as a member of N is protected, and the reference occurs in a
723 member or friend of class N, or in a member or friend of a
724 class P derived from N, where m as a member of P is public, private
727 Here DERIVED is a possible P, DECL is m and BINFO_TYPE (binfo) is N. */
729 /* If DERIVED isn't derived from N, then it can't be a P. */
730 if (!DERIVED_FROM_P (BINFO_TYPE (binfo), derived))
733 access = access_in_type (derived, decl);
735 /* If m is inaccessible in DERIVED, then it's not a P. */
736 if (access == ak_none)
741 When a friend or a member function of a derived class references
742 a protected nonstatic member of a base class, an access check
743 applies in addition to those described earlier in clause
744 _class.access_) Except when forming a pointer to member
745 (_expr.unary.op_), the access must be through a pointer to,
746 reference to, or object of the derived class itself (or any class
747 derived from that class) (_expr.ref_). If the access is to form
748 a pointer to member, the nested-name-specifier shall name the
749 derived class (or any class derived from that class). */
750 if (DECL_NONSTATIC_MEMBER_P (decl))
752 /* We can tell through what the reference is occurring by
753 chasing BINFO up to the root. */
755 while (BINFO_INHERITANCE_CHAIN (t))
756 t = BINFO_INHERITANCE_CHAIN (t);
758 if (!DERIVED_FROM_P (derived, BINFO_TYPE (t)))
765 /* Returns nonzero if SCOPE is a friend of a type which would be able
766 to access DECL through the object indicated by BINFO. */
769 friend_accessible_p (tree scope, tree decl, tree binfo)
771 tree befriending_classes;
777 if (TREE_CODE (scope) == FUNCTION_DECL
778 || DECL_FUNCTION_TEMPLATE_P (scope))
779 befriending_classes = DECL_BEFRIENDING_CLASSES (scope);
780 else if (TYPE_P (scope))
781 befriending_classes = CLASSTYPE_BEFRIENDING_CLASSES (scope);
785 for (t = befriending_classes; t; t = TREE_CHAIN (t))
786 if (protected_accessible_p (decl, TREE_VALUE (t), binfo))
789 /* Nested classes have the same access as their enclosing types, as
790 per DR 45 (this is a change from the standard). */
792 for (t = TYPE_CONTEXT (scope); t && TYPE_P (t); t = TYPE_CONTEXT (t))
793 if (protected_accessible_p (decl, t, binfo))
796 if (TREE_CODE (scope) == FUNCTION_DECL
797 || DECL_FUNCTION_TEMPLATE_P (scope))
799 /* Perhaps this SCOPE is a member of a class which is a
801 if (DECL_CLASS_SCOPE_P (scope)
802 && friend_accessible_p (DECL_CONTEXT (scope), decl, binfo))
805 /* Or an instantiation of something which is a friend. */
806 if (DECL_TEMPLATE_INFO (scope))
809 /* Increment processing_template_decl to make sure that
810 dependent_type_p works correctly. */
811 ++processing_template_decl;
812 ret = friend_accessible_p (DECL_TI_TEMPLATE (scope), decl, binfo);
813 --processing_template_decl;
821 /* Called via dfs_walk_once_accessible from accessible_p */
824 dfs_accessible_post (tree binfo, void *data ATTRIBUTE_UNUSED)
826 if (BINFO_ACCESS (binfo) != ak_none)
828 tree scope = current_scope ();
829 if (scope && TREE_CODE (scope) != NAMESPACE_DECL
830 && is_friend (BINFO_TYPE (binfo), scope))
837 /* DECL is a declaration from a base class of TYPE, which was the
838 class used to name DECL. Return nonzero if, in the current
839 context, DECL is accessible. If TYPE is actually a BINFO node,
840 then we can tell in what context the access is occurring by looking
841 at the most derived class along the path indicated by BINFO. If
842 CONSIDER_LOCAL is true, do consider special access the current
843 scope or friendship thereof we might have. */
846 accessible_p (tree type, tree decl, bool consider_local_p)
852 /* Nonzero if it's OK to access DECL if it has protected
853 accessibility in TYPE. */
854 int protected_ok = 0;
856 /* If this declaration is in a block or namespace scope, there's no
858 if (!TYPE_P (context_for_name_lookup (decl)))
861 /* There is no need to perform access checks inside a thunk. */
862 scope = current_scope ();
863 if (scope && DECL_THUNK_P (scope))
866 /* In a template declaration, we cannot be sure whether the
867 particular specialization that is instantiated will be a friend
868 or not. Therefore, all access checks are deferred until
869 instantiation. However, PROCESSING_TEMPLATE_DECL is set in the
870 parameter list for a template (because we may see dependent types
871 in default arguments for template parameters), and access
872 checking should be performed in the outermost parameter list. */
873 if (processing_template_decl
874 && (!processing_template_parmlist || processing_template_decl > 1))
880 type = BINFO_TYPE (type);
883 binfo = TYPE_BINFO (type);
885 /* [class.access.base]
887 A member m is accessible when named in class N if
889 --m as a member of N is public, or
891 --m as a member of N is private, and the reference occurs in a
892 member or friend of class N, or
894 --m as a member of N is protected, and the reference occurs in a
895 member or friend of class N, or in a member or friend of a
896 class P derived from N, where m as a member of P is private or
899 --there exists a base class B of N that is accessible at the point
900 of reference, and m is accessible when named in class B.
902 We walk the base class hierarchy, checking these conditions. */
904 if (consider_local_p)
906 /* Figure out where the reference is occurring. Check to see if
907 DECL is private or protected in this scope, since that will
908 determine whether protected access is allowed. */
909 if (current_class_type)
910 protected_ok = protected_accessible_p (decl,
911 current_class_type, binfo);
913 /* Now, loop through the classes of which we are a friend. */
915 protected_ok = friend_accessible_p (scope, decl, binfo);
918 /* Standardize the binfo that access_in_type will use. We don't
919 need to know what path was chosen from this point onwards. */
920 binfo = TYPE_BINFO (type);
922 /* Compute the accessibility of DECL in the class hierarchy
923 dominated by type. */
924 access = access_in_type (type, decl);
925 if (access == ak_public
926 || (access == ak_protected && protected_ok))
929 if (!consider_local_p)
932 /* Walk the hierarchy again, looking for a base class that allows
934 return dfs_walk_once_accessible (binfo, /*friends=*/true,
935 NULL, dfs_accessible_post, NULL)
939 struct lookup_field_info {
940 /* The type in which we're looking. */
942 /* The name of the field for which we're looking. */
944 /* If non-NULL, the current result of the lookup. */
946 /* The path to RVAL. */
948 /* If non-NULL, the lookup was ambiguous, and this is a list of the
951 /* If nonzero, we are looking for types, not data members. */
953 /* If something went wrong, a message indicating what. */
957 /* Nonzero for a class member means that it is shared between all objects
960 [class.member.lookup]:If the resulting set of declarations are not all
961 from sub-objects of the same type, or the set has a nonstatic member
962 and includes members from distinct sub-objects, there is an ambiguity
963 and the program is ill-formed.
965 This function checks that T contains no nonstatic members. */
968 shared_member_p (tree t)
970 if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == TYPE_DECL \
971 || TREE_CODE (t) == CONST_DECL)
973 if (is_overloaded_fn (t))
975 for (; t; t = OVL_NEXT (t))
977 tree fn = OVL_CURRENT (t);
978 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
986 /* Routine to see if the sub-object denoted by the binfo PARENT can be
987 found as a base class and sub-object of the object denoted by
991 is_subobject_of_p (tree parent, tree binfo)
995 for (probe = parent; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
999 if (BINFO_VIRTUAL_P (probe))
1000 return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (binfo))
1006 /* DATA is really a struct lookup_field_info. Look for a field with
1007 the name indicated there in BINFO. If this function returns a
1008 non-NULL value it is the result of the lookup. Called from
1009 lookup_field via breadth_first_search. */
1012 lookup_field_r (tree binfo, void *data)
1014 struct lookup_field_info *lfi = (struct lookup_field_info *) data;
1015 tree type = BINFO_TYPE (binfo);
1016 tree nval = NULL_TREE;
1018 /* If this is a dependent base, don't look in it. */
1019 if (BINFO_DEPENDENT_BASE_P (binfo))
1022 /* If this base class is hidden by the best-known value so far, we
1023 don't need to look. */
1024 if (lfi->rval_binfo && BINFO_INHERITANCE_CHAIN (binfo) == lfi->rval_binfo
1025 && !BINFO_VIRTUAL_P (binfo))
1026 return dfs_skip_bases;
1028 /* First, look for a function. There can't be a function and a data
1029 member with the same name, and if there's a function and a type
1030 with the same name, the type is hidden by the function. */
1031 if (!lfi->want_type)
1033 int idx = lookup_fnfields_1 (type, lfi->name);
1035 nval = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
1039 /* Look for a data member or type. */
1040 nval = lookup_field_1 (type, lfi->name, lfi->want_type);
1042 /* If there is no declaration with the indicated name in this type,
1043 then there's nothing to do. */
1047 /* If we're looking up a type (as with an elaborated type specifier)
1048 we ignore all non-types we find. */
1049 if (lfi->want_type && TREE_CODE (nval) != TYPE_DECL
1050 && !DECL_CLASS_TEMPLATE_P (nval))
1052 if (lfi->name == TYPE_IDENTIFIER (type))
1054 /* If the aggregate has no user defined constructors, we allow
1055 it to have fields with the same name as the enclosing type.
1056 If we are looking for that name, find the corresponding
1058 for (nval = TREE_CHAIN (nval); nval; nval = TREE_CHAIN (nval))
1059 if (DECL_NAME (nval) == lfi->name
1060 && TREE_CODE (nval) == TYPE_DECL)
1065 if (!nval && CLASSTYPE_NESTED_UTDS (type) != NULL)
1067 binding_entry e = binding_table_find (CLASSTYPE_NESTED_UTDS (type),
1070 nval = TYPE_MAIN_DECL (e->type);
1076 /* If the lookup already found a match, and the new value doesn't
1077 hide the old one, we might have an ambiguity. */
1079 && !is_subobject_of_p (lfi->rval_binfo, binfo))
1082 if (nval == lfi->rval && shared_member_p (nval))
1083 /* The two things are really the same. */
1085 else if (is_subobject_of_p (binfo, lfi->rval_binfo))
1086 /* The previous value hides the new one. */
1090 /* We have a real ambiguity. We keep a chain of all the
1092 if (!lfi->ambiguous && lfi->rval)
1094 /* This is the first time we noticed an ambiguity. Add
1095 what we previously thought was a reasonable candidate
1097 lfi->ambiguous = tree_cons (NULL_TREE, lfi->rval, NULL_TREE);
1098 TREE_TYPE (lfi->ambiguous) = error_mark_node;
1101 /* Add the new value. */
1102 lfi->ambiguous = tree_cons (NULL_TREE, nval, lfi->ambiguous);
1103 TREE_TYPE (lfi->ambiguous) = error_mark_node;
1104 lfi->errstr = "request for member %qD is ambiguous";
1110 lfi->rval_binfo = binfo;
1114 /* Don't look for constructors or destructors in base classes. */
1115 if (IDENTIFIER_CTOR_OR_DTOR_P (lfi->name))
1116 return dfs_skip_bases;
1120 /* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO,
1121 BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO,
1122 FUNCTIONS, and OPTYPE respectively. */
1125 build_baselink (tree binfo, tree access_binfo, tree functions, tree optype)
1129 gcc_assert (TREE_CODE (functions) == FUNCTION_DECL
1130 || TREE_CODE (functions) == TEMPLATE_DECL
1131 || TREE_CODE (functions) == TEMPLATE_ID_EXPR
1132 || TREE_CODE (functions) == OVERLOAD);
1133 gcc_assert (!optype || TYPE_P (optype));
1134 gcc_assert (TREE_TYPE (functions));
1136 baselink = make_node (BASELINK);
1137 TREE_TYPE (baselink) = TREE_TYPE (functions);
1138 BASELINK_BINFO (baselink) = binfo;
1139 BASELINK_ACCESS_BINFO (baselink) = access_binfo;
1140 BASELINK_FUNCTIONS (baselink) = functions;
1141 BASELINK_OPTYPE (baselink) = optype;
1146 /* Look for a member named NAME in an inheritance lattice dominated by
1147 XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
1148 is 1, we enforce accessibility. If PROTECT is zero, then, for an
1149 ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
1150 messages about inaccessible or ambiguous lookup. If PROTECT is 2,
1151 we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
1152 TREE_VALUEs are the list of ambiguous candidates.
1154 WANT_TYPE is 1 when we should only return TYPE_DECLs.
1156 If nothing can be found return NULL_TREE and do not issue an error. */
1159 lookup_member (tree xbasetype, tree name, int protect, bool want_type)
1161 tree rval, rval_binfo = NULL_TREE;
1162 tree type = NULL_TREE, basetype_path = NULL_TREE;
1163 struct lookup_field_info lfi;
1165 /* rval_binfo is the binfo associated with the found member, note,
1166 this can be set with useful information, even when rval is not
1167 set, because it must deal with ALL members, not just non-function
1168 members. It is used for ambiguity checking and the hidden
1169 checks. Whereas rval is only set if a proper (not hidden)
1170 non-function member is found. */
1172 const char *errstr = 0;
1174 if (name == error_mark_node)
1177 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1179 if (TREE_CODE (xbasetype) == TREE_BINFO)
1181 type = BINFO_TYPE (xbasetype);
1182 basetype_path = xbasetype;
1186 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype)))
1189 xbasetype = NULL_TREE;
1192 type = complete_type (type);
1194 basetype_path = TYPE_BINFO (type);
1199 #ifdef GATHER_STATISTICS
1200 n_calls_lookup_field++;
1201 #endif /* GATHER_STATISTICS */
1203 memset (&lfi, 0, sizeof (lfi));
1206 lfi.want_type = want_type;
1207 dfs_walk_all (basetype_path, &lookup_field_r, NULL, &lfi);
1209 rval_binfo = lfi.rval_binfo;
1211 type = BINFO_TYPE (rval_binfo);
1212 errstr = lfi.errstr;
1214 /* If we are not interested in ambiguities, don't report them;
1215 just return NULL_TREE. */
1216 if (!protect && lfi.ambiguous)
1222 return lfi.ambiguous;
1229 In the case of overloaded function names, access control is
1230 applied to the function selected by overloaded resolution.
1232 We cannot check here, even if RVAL is only a single non-static
1233 member function, since we do not know what the "this" pointer
1236 class A { protected: void f(); };
1237 class B : public A {
1244 only the first call to "f" is valid. However, if the function is
1245 static, we can check. */
1247 && !really_overloaded_fn (rval)
1248 && !(TREE_CODE (rval) == FUNCTION_DECL
1249 && DECL_NONSTATIC_MEMBER_FUNCTION_P (rval)))
1250 perform_or_defer_access_check (basetype_path, rval, rval);
1252 if (errstr && protect)
1254 error (errstr, name, type);
1256 print_candidates (lfi.ambiguous);
1257 rval = error_mark_node;
1260 if (rval && is_overloaded_fn (rval))
1261 rval = build_baselink (rval_binfo, basetype_path, rval,
1262 (IDENTIFIER_TYPENAME_P (name)
1263 ? TREE_TYPE (name): NULL_TREE));
1267 /* Like lookup_member, except that if we find a function member we
1268 return NULL_TREE. */
1271 lookup_field (tree xbasetype, tree name, int protect, bool want_type)
1273 tree rval = lookup_member (xbasetype, name, protect, want_type);
1275 /* Ignore functions, but propagate the ambiguity list. */
1276 if (!error_operand_p (rval)
1277 && (rval && BASELINK_P (rval)))
1283 /* Like lookup_member, except that if we find a non-function member we
1284 return NULL_TREE. */
1287 lookup_fnfields (tree xbasetype, tree name, int protect)
1289 tree rval = lookup_member (xbasetype, name, protect, /*want_type=*/false);
1291 /* Ignore non-functions, but propagate the ambiguity list. */
1292 if (!error_operand_p (rval)
1293 && (rval && !BASELINK_P (rval)))
1299 /* Return the index in the CLASSTYPE_METHOD_VEC for CLASS_TYPE
1300 corresponding to "operator TYPE ()", or -1 if there is no such
1301 operator. Only CLASS_TYPE itself is searched; this routine does
1302 not scan the base classes of CLASS_TYPE. */
1305 lookup_conversion_operator (tree class_type, tree type)
1309 if (TYPE_HAS_CONVERSION (class_type))
1313 VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (class_type);
1315 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
1316 VEC_iterate (tree, methods, i, fn); ++i)
1318 /* All the conversion operators come near the beginning of
1319 the class. Therefore, if FN is not a conversion
1320 operator, there is no matching conversion operator in
1322 fn = OVL_CURRENT (fn);
1323 if (!DECL_CONV_FN_P (fn))
1326 if (TREE_CODE (fn) == TEMPLATE_DECL)
1327 /* All the templated conversion functions are on the same
1328 slot, so remember it. */
1330 else if (same_type_p (DECL_CONV_FN_TYPE (fn), type))
1338 /* TYPE is a class type. Return the index of the fields within
1339 the method vector with name NAME, or -1 is no such field exists. */
1342 lookup_fnfields_1 (tree type, tree name)
1344 VEC(tree,gc) *method_vec;
1349 if (!CLASS_TYPE_P (type))
1352 if (COMPLETE_TYPE_P (type))
1354 if ((name == ctor_identifier
1355 || name == base_ctor_identifier
1356 || name == complete_ctor_identifier))
1358 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
1359 lazily_declare_fn (sfk_constructor, type);
1360 if (CLASSTYPE_LAZY_COPY_CTOR (type))
1361 lazily_declare_fn (sfk_copy_constructor, type);
1362 if (CLASSTYPE_LAZY_MOVE_CTOR (type))
1363 lazily_declare_fn (sfk_move_constructor, type);
1365 else if (name == ansi_assopname(NOP_EXPR)
1366 && CLASSTYPE_LAZY_ASSIGNMENT_OP (type))
1367 lazily_declare_fn (sfk_assignment_operator, type);
1368 else if ((name == dtor_identifier
1369 || name == base_dtor_identifier
1370 || name == complete_dtor_identifier
1371 || name == deleting_dtor_identifier)
1372 && CLASSTYPE_LAZY_DESTRUCTOR (type))
1373 lazily_declare_fn (sfk_destructor, type);
1376 method_vec = CLASSTYPE_METHOD_VEC (type);
1380 #ifdef GATHER_STATISTICS
1381 n_calls_lookup_fnfields_1++;
1382 #endif /* GATHER_STATISTICS */
1384 /* Constructors are first... */
1385 if (name == ctor_identifier)
1387 fn = CLASSTYPE_CONSTRUCTORS (type);
1388 return fn ? CLASSTYPE_CONSTRUCTOR_SLOT : -1;
1390 /* and destructors are second. */
1391 if (name == dtor_identifier)
1393 fn = CLASSTYPE_DESTRUCTORS (type);
1394 return fn ? CLASSTYPE_DESTRUCTOR_SLOT : -1;
1396 if (IDENTIFIER_TYPENAME_P (name))
1397 return lookup_conversion_operator (type, TREE_TYPE (name));
1399 /* Skip the conversion operators. */
1400 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
1401 VEC_iterate (tree, method_vec, i, fn);
1403 if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1406 /* If the type is complete, use binary search. */
1407 if (COMPLETE_TYPE_P (type))
1413 hi = VEC_length (tree, method_vec);
1418 #ifdef GATHER_STATISTICS
1419 n_outer_fields_searched++;
1420 #endif /* GATHER_STATISTICS */
1422 tmp = VEC_index (tree, method_vec, i);
1423 tmp = DECL_NAME (OVL_CURRENT (tmp));
1426 else if (tmp < name)
1433 for (; VEC_iterate (tree, method_vec, i, fn); ++i)
1435 #ifdef GATHER_STATISTICS
1436 n_outer_fields_searched++;
1437 #endif /* GATHER_STATISTICS */
1438 if (DECL_NAME (OVL_CURRENT (fn)) == name)
1445 /* Like lookup_fnfields_1, except that the name is extracted from
1446 FUNCTION, which is a FUNCTION_DECL or a TEMPLATE_DECL. */
1449 class_method_index_for_fn (tree class_type, tree function)
1451 gcc_assert (TREE_CODE (function) == FUNCTION_DECL
1452 || DECL_FUNCTION_TEMPLATE_P (function));
1454 return lookup_fnfields_1 (class_type,
1455 DECL_CONSTRUCTOR_P (function) ? ctor_identifier :
1456 DECL_DESTRUCTOR_P (function) ? dtor_identifier :
1457 DECL_NAME (function));
1461 /* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
1462 the class or namespace used to qualify the name. CONTEXT_CLASS is
1463 the class corresponding to the object in which DECL will be used.
1464 Return a possibly modified version of DECL that takes into account
1467 In particular, consider an expression like `B::m' in the context of
1468 a derived class `D'. If `B::m' has been resolved to a BASELINK,
1469 then the most derived class indicated by the BASELINK_BINFO will be
1470 `B', not `D'. This function makes that adjustment. */
1473 adjust_result_of_qualified_name_lookup (tree decl,
1474 tree qualifying_scope,
1477 if (context_class && context_class != error_mark_node
1478 && CLASS_TYPE_P (context_class)
1479 && CLASS_TYPE_P (qualifying_scope)
1480 && DERIVED_FROM_P (qualifying_scope, context_class)
1481 && BASELINK_P (decl))
1485 /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
1486 Because we do not yet know which function will be chosen by
1487 overload resolution, we cannot yet check either accessibility
1488 or ambiguity -- in either case, the choice of a static member
1489 function might make the usage valid. */
1490 base = lookup_base (context_class, qualifying_scope,
1491 ba_unique | ba_quiet, NULL);
1494 BASELINK_ACCESS_BINFO (decl) = base;
1495 BASELINK_BINFO (decl)
1496 = lookup_base (base, BINFO_TYPE (BASELINK_BINFO (decl)),
1497 ba_unique | ba_quiet,
1506 /* Walk the class hierarchy within BINFO, in a depth-first traversal.
1507 PRE_FN is called in preorder, while POST_FN is called in postorder.
1508 If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
1509 walked. If PRE_FN or POST_FN returns a different non-NULL value,
1510 that value is immediately returned and the walk is terminated. One
1511 of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
1512 POST_FN are passed the binfo to examine and the caller's DATA
1513 value. All paths are walked, thus virtual and morally virtual
1514 binfos can be multiply walked. */
1517 dfs_walk_all (tree binfo, tree (*pre_fn) (tree, void *),
1518 tree (*post_fn) (tree, void *), void *data)
1524 /* Call the pre-order walking function. */
1527 rval = pre_fn (binfo, data);
1530 if (rval == dfs_skip_bases)
1536 /* Find the next child binfo to walk. */
1537 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1539 rval = dfs_walk_all (base_binfo, pre_fn, post_fn, data);
1545 /* Call the post-order walking function. */
1548 rval = post_fn (binfo, data);
1549 gcc_assert (rval != dfs_skip_bases);
1556 /* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1557 that binfos are walked at most once. */
1560 dfs_walk_once_r (tree binfo, tree (*pre_fn) (tree, void *),
1561 tree (*post_fn) (tree, void *), void *data)
1567 /* Call the pre-order walking function. */
1570 rval = pre_fn (binfo, data);
1573 if (rval == dfs_skip_bases)
1580 /* Find the next child binfo to walk. */
1581 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1583 if (BINFO_VIRTUAL_P (base_binfo))
1585 if (BINFO_MARKED (base_binfo))
1587 BINFO_MARKED (base_binfo) = 1;
1590 rval = dfs_walk_once_r (base_binfo, pre_fn, post_fn, data);
1596 /* Call the post-order walking function. */
1599 rval = post_fn (binfo, data);
1600 gcc_assert (rval != dfs_skip_bases);
1607 /* Worker for dfs_walk_once. Recursively unmark the virtual base binfos of
1611 dfs_unmark_r (tree binfo)
1616 /* Process the basetypes. */
1617 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1619 if (BINFO_VIRTUAL_P (base_binfo))
1621 if (!BINFO_MARKED (base_binfo))
1623 BINFO_MARKED (base_binfo) = 0;
1625 /* Only walk, if it can contain more virtual bases. */
1626 if (CLASSTYPE_VBASECLASSES (BINFO_TYPE (base_binfo)))
1627 dfs_unmark_r (base_binfo);
1631 /* Like dfs_walk_all, except that binfos are not multiply walked. For
1632 non-diamond shaped hierarchies this is the same as dfs_walk_all.
1633 For diamond shaped hierarchies we must mark the virtual bases, to
1634 avoid multiple walks. */
1637 dfs_walk_once (tree binfo, tree (*pre_fn) (tree, void *),
1638 tree (*post_fn) (tree, void *), void *data)
1640 static int active = 0; /* We must not be called recursively. */
1643 gcc_assert (pre_fn || post_fn);
1644 gcc_assert (!active);
1647 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo)))
1648 /* We are not diamond shaped, and therefore cannot encounter the
1649 same binfo twice. */
1650 rval = dfs_walk_all (binfo, pre_fn, post_fn, data);
1653 rval = dfs_walk_once_r (binfo, pre_fn, post_fn, data);
1654 if (!BINFO_INHERITANCE_CHAIN (binfo))
1656 /* We are at the top of the hierarchy, and can use the
1657 CLASSTYPE_VBASECLASSES list for unmarking the virtual
1659 VEC(tree,gc) *vbases;
1663 for (vbases = CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)), ix = 0;
1664 VEC_iterate (tree, vbases, ix, base_binfo); ix++)
1665 BINFO_MARKED (base_binfo) = 0;
1668 dfs_unmark_r (binfo);
1676 /* Worker function for dfs_walk_once_accessible. Behaves like
1677 dfs_walk_once_r, except (a) FRIENDS_P is true if special
1678 access given by the current context should be considered, (b) ONCE
1679 indicates whether bases should be marked during traversal. */
1682 dfs_walk_once_accessible_r (tree binfo, bool friends_p, bool once,
1683 tree (*pre_fn) (tree, void *),
1684 tree (*post_fn) (tree, void *), void *data)
1686 tree rval = NULL_TREE;
1690 /* Call the pre-order walking function. */
1693 rval = pre_fn (binfo, data);
1696 if (rval == dfs_skip_bases)
1703 /* Find the next child binfo to walk. */
1704 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1706 bool mark = once && BINFO_VIRTUAL_P (base_binfo);
1708 if (mark && BINFO_MARKED (base_binfo))
1711 /* If the base is inherited via private or protected
1712 inheritance, then we can't see it, unless we are a friend of
1713 the current binfo. */
1714 if (BINFO_BASE_ACCESS (binfo, ix) != access_public_node)
1719 scope = current_scope ();
1721 || TREE_CODE (scope) == NAMESPACE_DECL
1722 || !is_friend (BINFO_TYPE (binfo), scope))
1727 BINFO_MARKED (base_binfo) = 1;
1729 rval = dfs_walk_once_accessible_r (base_binfo, friends_p, once,
1730 pre_fn, post_fn, data);
1736 /* Call the post-order walking function. */
1739 rval = post_fn (binfo, data);
1740 gcc_assert (rval != dfs_skip_bases);
1747 /* Like dfs_walk_once except that only accessible bases are walked.
1748 FRIENDS_P indicates whether friendship of the local context
1749 should be considered when determining accessibility. */
1752 dfs_walk_once_accessible (tree binfo, bool friends_p,
1753 tree (*pre_fn) (tree, void *),
1754 tree (*post_fn) (tree, void *), void *data)
1756 bool diamond_shaped = CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo));
1757 tree rval = dfs_walk_once_accessible_r (binfo, friends_p, diamond_shaped,
1758 pre_fn, post_fn, data);
1762 if (!BINFO_INHERITANCE_CHAIN (binfo))
1764 /* We are at the top of the hierarchy, and can use the
1765 CLASSTYPE_VBASECLASSES list for unmarking the virtual
1767 VEC(tree,gc) *vbases;
1771 for (vbases = CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)), ix = 0;
1772 VEC_iterate (tree, vbases, ix, base_binfo); ix++)
1773 BINFO_MARKED (base_binfo) = 0;
1776 dfs_unmark_r (binfo);
1781 /* Check that virtual overrider OVERRIDER is acceptable for base function
1782 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
1785 check_final_overrider (tree overrider, tree basefn)
1787 tree over_type = TREE_TYPE (overrider);
1788 tree base_type = TREE_TYPE (basefn);
1789 tree over_return = TREE_TYPE (over_type);
1790 tree base_return = TREE_TYPE (base_type);
1791 tree over_throw = TYPE_RAISES_EXCEPTIONS (over_type);
1792 tree base_throw = TYPE_RAISES_EXCEPTIONS (base_type);
1795 if (DECL_INVALID_OVERRIDER_P (overrider))
1798 if (same_type_p (base_return, over_return))
1800 else if ((CLASS_TYPE_P (over_return) && CLASS_TYPE_P (base_return))
1801 || (TREE_CODE (base_return) == TREE_CODE (over_return)
1802 && POINTER_TYPE_P (base_return)))
1804 /* Potentially covariant. */
1805 unsigned base_quals, over_quals;
1807 fail = !POINTER_TYPE_P (base_return);
1810 fail = cp_type_quals (base_return) != cp_type_quals (over_return);
1812 base_return = TREE_TYPE (base_return);
1813 over_return = TREE_TYPE (over_return);
1815 base_quals = cp_type_quals (base_return);
1816 over_quals = cp_type_quals (over_return);
1818 if ((base_quals & over_quals) != over_quals)
1821 if (CLASS_TYPE_P (base_return) && CLASS_TYPE_P (over_return))
1823 tree binfo = lookup_base (over_return, base_return,
1824 ba_check | ba_quiet, NULL);
1830 && can_convert (TREE_TYPE (base_type), TREE_TYPE (over_type)))
1831 /* GNU extension, allow trivial pointer conversions such as
1832 converting to void *, or qualification conversion. */
1834 /* can_convert will permit user defined conversion from a
1835 (reference to) class type. We must reject them. */
1836 over_return = non_reference (TREE_TYPE (over_type));
1837 if (CLASS_TYPE_P (over_return))
1841 warning (0, "deprecated covariant return type for %q+#D",
1843 warning (0, " overriding %q+#D", basefn);
1857 error ("invalid covariant return type for %q+#D", overrider);
1858 error (" overriding %q+#D", basefn);
1862 error ("conflicting return type specified for %q+#D", overrider);
1863 error (" overriding %q+#D", basefn);
1865 DECL_INVALID_OVERRIDER_P (overrider) = 1;
1869 /* Check throw specifier is at least as strict. */
1870 if (!comp_except_specs (base_throw, over_throw, 0))
1872 error ("looser throw specifier for %q+#F", overrider);
1873 error (" overriding %q+#F", basefn);
1874 DECL_INVALID_OVERRIDER_P (overrider) = 1;
1878 /* Check for conflicting type attributes. */
1879 if (!targetm.comp_type_attributes (over_type, base_type))
1881 error ("conflicting type attributes specified for %q+#D", overrider);
1882 error (" overriding %q+#D", basefn);
1883 DECL_INVALID_OVERRIDER_P (overrider) = 1;
1887 if (DECL_DELETED_FN (basefn) != DECL_DELETED_FN (overrider))
1889 if (DECL_DELETED_FN (overrider))
1891 error ("deleted function %q+D", overrider);
1892 error ("overriding non-deleted function %q+D", basefn);
1896 error ("non-deleted function %q+D", overrider);
1897 error ("overriding deleted function %q+D", basefn);
1904 /* Given a class TYPE, and a function decl FNDECL, look for
1905 virtual functions in TYPE's hierarchy which FNDECL overrides.
1906 We do not look in TYPE itself, only its bases.
1908 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
1909 find that it overrides anything.
1911 We check that every function which is overridden, is correctly
1915 look_for_overrides (tree type, tree fndecl)
1917 tree binfo = TYPE_BINFO (type);
1922 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1924 tree basetype = BINFO_TYPE (base_binfo);
1926 if (TYPE_POLYMORPHIC_P (basetype))
1927 found += look_for_overrides_r (basetype, fndecl);
1932 /* Look in TYPE for virtual functions with the same signature as
1936 look_for_overrides_here (tree type, tree fndecl)
1940 /* If there are no methods in TYPE (meaning that only implicitly
1941 declared methods will ever be provided for TYPE), then there are
1942 no virtual functions. */
1943 if (!CLASSTYPE_METHOD_VEC (type))
1946 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fndecl))
1947 ix = CLASSTYPE_DESTRUCTOR_SLOT;
1949 ix = lookup_fnfields_1 (type, DECL_NAME (fndecl));
1952 tree fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
1954 for (; fns; fns = OVL_NEXT (fns))
1956 tree fn = OVL_CURRENT (fns);
1958 if (!DECL_VIRTUAL_P (fn))
1959 /* Not a virtual. */;
1960 else if (DECL_CONTEXT (fn) != type)
1961 /* Introduced with a using declaration. */;
1962 else if (DECL_STATIC_FUNCTION_P (fndecl))
1964 tree btypes = TYPE_ARG_TYPES (TREE_TYPE (fn));
1965 tree dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1966 if (compparms (TREE_CHAIN (btypes), dtypes))
1969 else if (same_signature_p (fndecl, fn))
1976 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
1977 TYPE itself and its bases. */
1980 look_for_overrides_r (tree type, tree fndecl)
1982 tree fn = look_for_overrides_here (type, fndecl);
1985 if (DECL_STATIC_FUNCTION_P (fndecl))
1987 /* A static member function cannot match an inherited
1988 virtual member function. */
1989 error ("%q+#D cannot be declared", fndecl);
1990 error (" since %q+#D declared in base class", fn);
1994 /* It's definitely virtual, even if not explicitly set. */
1995 DECL_VIRTUAL_P (fndecl) = 1;
1996 check_final_overrider (fndecl, fn);
2001 /* We failed to find one declared in this class. Look in its bases. */
2002 return look_for_overrides (type, fndecl);
2005 /* Called via dfs_walk from dfs_get_pure_virtuals. */
2008 dfs_get_pure_virtuals (tree binfo, void *data)
2010 tree type = (tree) data;
2012 /* We're not interested in primary base classes; the derived class
2013 of which they are a primary base will contain the information we
2015 if (!BINFO_PRIMARY_P (binfo))
2019 for (virtuals = BINFO_VIRTUALS (binfo);
2021 virtuals = TREE_CHAIN (virtuals))
2022 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals)))
2023 VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (type),
2030 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
2033 get_pure_virtuals (tree type)
2035 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
2036 is going to be overridden. */
2037 CLASSTYPE_PURE_VIRTUALS (type) = NULL;
2038 /* Now, run through all the bases which are not primary bases, and
2039 collect the pure virtual functions. We look at the vtable in
2040 each class to determine what pure virtual functions are present.
2041 (A primary base is not interesting because the derived class of
2042 which it is a primary base will contain vtable entries for the
2043 pure virtuals in the base class. */
2044 dfs_walk_once (TYPE_BINFO (type), NULL, dfs_get_pure_virtuals, type);
2047 /* Debug info for C++ classes can get very large; try to avoid
2048 emitting it everywhere.
2050 Note that this optimization wins even when the target supports
2051 BINCL (if only slightly), and reduces the amount of work for the
2055 maybe_suppress_debug_info (tree t)
2057 if (write_symbols == NO_DEBUG)
2060 /* We might have set this earlier in cp_finish_decl. */
2061 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 0;
2063 /* Always emit the information for each class every time. */
2064 if (flag_emit_class_debug_always)
2067 /* If we already know how we're handling this class, handle debug info
2069 if (CLASSTYPE_INTERFACE_KNOWN (t))
2071 if (CLASSTYPE_INTERFACE_ONLY (t))
2072 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
2073 /* else don't set it. */
2075 /* If the class has a vtable, write out the debug info along with
2077 else if (TYPE_CONTAINS_VPTR_P (t))
2078 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
2080 /* Otherwise, just emit the debug info normally. */
2083 /* Note that we want debugging information for a base class of a class
2084 whose vtable is being emitted. Normally, this would happen because
2085 calling the constructor for a derived class implies calling the
2086 constructors for all bases, which involve initializing the
2087 appropriate vptr with the vtable for the base class; but in the
2088 presence of optimization, this initialization may be optimized
2089 away, so we tell finish_vtable_vardecl that we want the debugging
2090 information anyway. */
2093 dfs_debug_mark (tree binfo, void *data ATTRIBUTE_UNUSED)
2095 tree t = BINFO_TYPE (binfo);
2097 if (CLASSTYPE_DEBUG_REQUESTED (t))
2098 return dfs_skip_bases;
2100 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
2105 /* Write out the debugging information for TYPE, whose vtable is being
2106 emitted. Also walk through our bases and note that we want to
2107 write out information for them. This avoids the problem of not
2108 writing any debug info for intermediate basetypes whose
2109 constructors, and thus the references to their vtables, and thus
2110 the vtables themselves, were optimized away. */
2113 note_debug_info_needed (tree type)
2115 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
2117 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)) = 0;
2118 rest_of_type_compilation (type, toplevel_bindings_p ());
2121 dfs_walk_all (TYPE_BINFO (type), dfs_debug_mark, NULL, 0);
2125 print_search_statistics (void)
2127 #ifdef GATHER_STATISTICS
2128 fprintf (stderr, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
2129 n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1);
2130 fprintf (stderr, "%d fnfields searched in %d calls to lookup_fnfields\n",
2131 n_outer_fields_searched, n_calls_lookup_fnfields);
2132 fprintf (stderr, "%d calls to get_base_type\n", n_calls_get_base_type);
2133 #else /* GATHER_STATISTICS */
2134 fprintf (stderr, "no search statistics\n");
2135 #endif /* GATHER_STATISTICS */
2139 reinit_search_statistics (void)
2141 #ifdef GATHER_STATISTICS
2142 n_fields_searched = 0;
2143 n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0;
2144 n_calls_lookup_fnfields = 0, n_calls_lookup_fnfields_1 = 0;
2145 n_calls_get_base_type = 0;
2146 n_outer_fields_searched = 0;
2147 n_contexts_saved = 0;
2148 #endif /* GATHER_STATISTICS */
2151 /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2152 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2153 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2154 bases have been encountered already in the tree walk. PARENT_CONVS
2155 is the list of lists of conversion functions that could hide CONV
2156 and OTHER_CONVS is the list of lists of conversion functions that
2157 could hide or be hidden by CONV, should virtualness be involved in
2158 the hierarchy. Merely checking the conversion op's name is not
2159 enough because two conversion operators to the same type can have
2160 different names. Return nonzero if we are visible. */
2163 check_hidden_convs (tree binfo, int virtual_depth, int virtualness,
2164 tree to_type, tree parent_convs, tree other_convs)
2168 /* See if we are hidden by a parent conversion. */
2169 for (level = parent_convs; level; level = TREE_CHAIN (level))
2170 for (probe = TREE_VALUE (level); probe; probe = TREE_CHAIN (probe))
2171 if (same_type_p (to_type, TREE_TYPE (probe)))
2174 if (virtual_depth || virtualness)
2176 /* In a virtual hierarchy, we could be hidden, or could hide a
2177 conversion function on the other_convs list. */
2178 for (level = other_convs; level; level = TREE_CHAIN (level))
2184 if (!(virtual_depth || TREE_STATIC (level)))
2185 /* Neither is morally virtual, so cannot hide each other. */
2188 if (!TREE_VALUE (level))
2189 /* They evaporated away already. */
2192 they_hide_us = (virtual_depth
2193 && original_binfo (binfo, TREE_PURPOSE (level)));
2194 we_hide_them = (!they_hide_us && TREE_STATIC (level)
2195 && original_binfo (TREE_PURPOSE (level), binfo));
2197 if (!(we_hide_them || they_hide_us))
2198 /* Neither is within the other, so no hiding can occur. */
2201 for (prev = &TREE_VALUE (level), other = *prev; other;)
2203 if (same_type_p (to_type, TREE_TYPE (other)))
2206 /* We are hidden. */
2211 /* We hide the other one. */
2212 other = TREE_CHAIN (other);
2217 prev = &TREE_CHAIN (other);
2225 /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2226 of conversion functions, the first slot will be for the current
2227 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2228 of conversion functions from children of the current binfo,
2229 concatenated with conversions from elsewhere in the hierarchy --
2230 that list begins with OTHER_CONVS. Return a single list of lists
2231 containing only conversions from the current binfo and its
2235 split_conversions (tree my_convs, tree parent_convs,
2236 tree child_convs, tree other_convs)
2241 /* Remove the original other_convs portion from child_convs. */
2242 for (prev = NULL, t = child_convs;
2243 t != other_convs; prev = t, t = TREE_CHAIN (t))
2247 TREE_CHAIN (prev) = NULL_TREE;
2249 child_convs = NULL_TREE;
2251 /* Attach the child convs to any we had at this level. */
2254 my_convs = parent_convs;
2255 TREE_CHAIN (my_convs) = child_convs;
2258 my_convs = child_convs;
2263 /* Worker for lookup_conversions. Lookup conversion functions in
2264 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in
2265 a morally virtual base, and VIRTUALNESS is nonzero, if we've
2266 encountered virtual bases already in the tree walk. PARENT_CONVS &
2267 PARENT_TPL_CONVS are lists of list of conversions within parent
2268 binfos. OTHER_CONVS and OTHER_TPL_CONVS are conversions found
2269 elsewhere in the tree. Return the conversions found within this
2270 portion of the graph in CONVS and TPL_CONVS. Return nonzero is we
2271 encountered virtualness. We keep template and non-template
2272 conversions separate, to avoid unnecessary type comparisons.
2274 The located conversion functions are held in lists of lists. The
2275 TREE_VALUE of the outer list is the list of conversion functions
2276 found in a particular binfo. The TREE_PURPOSE of both the outer
2277 and inner lists is the binfo at which those conversions were
2278 found. TREE_STATIC is set for those lists within of morally
2279 virtual binfos. The TREE_VALUE of the inner list is the conversion
2280 function or overload itself. The TREE_TYPE of each inner list node
2281 is the converted-to type. */
2284 lookup_conversions_r (tree binfo,
2285 int virtual_depth, int virtualness,
2286 tree parent_convs, tree parent_tpl_convs,
2287 tree other_convs, tree other_tpl_convs,
2288 tree *convs, tree *tpl_convs)
2290 int my_virtualness = 0;
2291 tree my_convs = NULL_TREE;
2292 tree my_tpl_convs = NULL_TREE;
2293 tree child_convs = NULL_TREE;
2294 tree child_tpl_convs = NULL_TREE;
2297 VEC(tree,gc) *method_vec = CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo));
2300 /* If we have no conversion operators, then don't look. */
2301 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo)))
2303 *convs = *tpl_convs = NULL_TREE;
2308 if (BINFO_VIRTUAL_P (binfo))
2311 /* First, locate the unhidden ones at this level. */
2312 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
2313 VEC_iterate (tree, method_vec, i, conv);
2316 tree cur = OVL_CURRENT (conv);
2318 if (!DECL_CONV_FN_P (cur))
2321 if (TREE_CODE (cur) == TEMPLATE_DECL)
2323 /* Only template conversions can be overloaded, and we must
2324 flatten them out and check each one individually. */
2327 for (tpls = conv; tpls; tpls = OVL_NEXT (tpls))
2329 tree tpl = OVL_CURRENT (tpls);
2330 tree type = DECL_CONV_FN_TYPE (tpl);
2332 if (check_hidden_convs (binfo, virtual_depth, virtualness,
2333 type, parent_tpl_convs, other_tpl_convs))
2335 my_tpl_convs = tree_cons (binfo, tpl, my_tpl_convs);
2336 TREE_TYPE (my_tpl_convs) = type;
2339 TREE_STATIC (my_tpl_convs) = 1;
2347 tree name = DECL_NAME (cur);
2349 if (!IDENTIFIER_MARKED (name))
2351 tree type = DECL_CONV_FN_TYPE (cur);
2353 if (check_hidden_convs (binfo, virtual_depth, virtualness,
2354 type, parent_convs, other_convs))
2356 my_convs = tree_cons (binfo, conv, my_convs);
2357 TREE_TYPE (my_convs) = type;
2360 TREE_STATIC (my_convs) = 1;
2363 IDENTIFIER_MARKED (name) = 1;
2371 parent_convs = tree_cons (binfo, my_convs, parent_convs);
2373 TREE_STATIC (parent_convs) = 1;
2378 parent_tpl_convs = tree_cons (binfo, my_tpl_convs, parent_tpl_convs);
2380 TREE_STATIC (parent_tpl_convs) = 1;
2383 child_convs = other_convs;
2384 child_tpl_convs = other_tpl_convs;
2386 /* Now iterate over each base, looking for more conversions. */
2387 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2389 tree base_convs, base_tpl_convs;
2390 unsigned base_virtualness;
2392 base_virtualness = lookup_conversions_r (base_binfo,
2393 virtual_depth, virtualness,
2394 parent_convs, parent_tpl_convs,
2395 child_convs, child_tpl_convs,
2396 &base_convs, &base_tpl_convs);
2397 if (base_virtualness)
2398 my_virtualness = virtualness = 1;
2399 child_convs = chainon (base_convs, child_convs);
2400 child_tpl_convs = chainon (base_tpl_convs, child_tpl_convs);
2403 /* Unmark the conversions found at this level */
2404 for (conv = my_convs; conv; conv = TREE_CHAIN (conv))
2405 IDENTIFIER_MARKED (DECL_NAME (OVL_CURRENT (TREE_VALUE (conv)))) = 0;
2407 *convs = split_conversions (my_convs, parent_convs,
2408 child_convs, other_convs);
2409 *tpl_convs = split_conversions (my_tpl_convs, parent_tpl_convs,
2410 child_tpl_convs, other_tpl_convs);
2412 return my_virtualness;
2415 /* Return a TREE_LIST containing all the non-hidden user-defined
2416 conversion functions for TYPE (and its base-classes). The
2417 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2418 function. The TREE_PURPOSE is the BINFO from which the conversion
2419 functions in this node were selected. This function is effectively
2420 performing a set of member lookups as lookup_fnfield does, but
2421 using the type being converted to as the unique key, rather than the
2425 lookup_conversions (tree type)
2427 tree convs, tpl_convs;
2428 tree list = NULL_TREE;
2430 complete_type (type);
2431 if (!TYPE_BINFO (type))
2434 lookup_conversions_r (TYPE_BINFO (type), 0, 0,
2435 NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
2436 &convs, &tpl_convs);
2438 /* Flatten the list-of-lists */
2439 for (; convs; convs = TREE_CHAIN (convs))
2443 for (probe = TREE_VALUE (convs); probe; probe = next)
2445 next = TREE_CHAIN (probe);
2447 TREE_CHAIN (probe) = list;
2452 for (; tpl_convs; tpl_convs = TREE_CHAIN (tpl_convs))
2456 for (probe = TREE_VALUE (tpl_convs); probe; probe = next)
2458 next = TREE_CHAIN (probe);
2460 TREE_CHAIN (probe) = list;
2468 /* Returns the binfo of the first direct or indirect virtual base derived
2469 from BINFO, or NULL if binfo is not via virtual. */
2472 binfo_from_vbase (tree binfo)
2474 for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
2476 if (BINFO_VIRTUAL_P (binfo))
2482 /* Returns the binfo of the first direct or indirect virtual base derived
2483 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2487 binfo_via_virtual (tree binfo, tree limit)
2489 if (limit && !CLASSTYPE_VBASECLASSES (limit))
2490 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2493 for (; binfo && !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), limit);
2494 binfo = BINFO_INHERITANCE_CHAIN (binfo))
2496 if (BINFO_VIRTUAL_P (binfo))
2502 /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2503 Find the equivalent binfo within whatever graph HERE is located.
2504 This is the inverse of original_binfo. */
2507 copied_binfo (tree binfo, tree here)
2509 tree result = NULL_TREE;
2511 if (BINFO_VIRTUAL_P (binfo))
2515 for (t = here; BINFO_INHERITANCE_CHAIN (t);
2516 t = BINFO_INHERITANCE_CHAIN (t))
2519 result = binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (t));
2521 else if (BINFO_INHERITANCE_CHAIN (binfo))
2527 cbinfo = copied_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
2528 for (ix = 0; BINFO_BASE_ITERATE (cbinfo, ix, base_binfo); ix++)
2529 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), BINFO_TYPE (binfo)))
2531 result = base_binfo;
2537 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here), BINFO_TYPE (binfo)));
2541 gcc_assert (result);
2546 binfo_for_vbase (tree base, tree t)
2550 VEC(tree,gc) *vbases;
2552 for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
2553 VEC_iterate (tree, vbases, ix, binfo); ix++)
2554 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), base))
2559 /* BINFO is some base binfo of HERE, within some other
2560 hierarchy. Return the equivalent binfo, but in the hierarchy
2561 dominated by HERE. This is the inverse of copied_binfo. If BINFO
2562 is not a base binfo of HERE, returns NULL_TREE. */
2565 original_binfo (tree binfo, tree here)
2569 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (here)))
2571 else if (BINFO_VIRTUAL_P (binfo))
2572 result = (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here))
2573 ? binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (here))
2575 else if (BINFO_INHERITANCE_CHAIN (binfo))
2579 base_binfos = original_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
2585 for (ix = 0; (base_binfo = BINFO_BASE_BINFO (base_binfos, ix)); ix++)
2586 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
2587 BINFO_TYPE (binfo)))
2589 result = base_binfo;