1 /* Breadth-first and depth-first routines for
2 searching multiple-inheritance lattice for GNU C++.
3 Copyright (C) 1987-2013 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
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)
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.
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/>. */
22 /* High-level class interface. */
26 #include "coretypes.h"
35 static int is_subobject_of_p (tree, tree);
36 static tree dfs_lookup_base (tree, void *);
37 static tree dfs_dcast_hint_pre (tree, void *);
38 static tree dfs_dcast_hint_post (tree, void *);
39 static tree dfs_debug_mark (tree, void *);
40 static tree dfs_walk_once_r (tree, tree (*pre_fn) (tree, void *),
41 tree (*post_fn) (tree, void *), void *data);
42 static void dfs_unmark_r (tree);
43 static int check_hidden_convs (tree, int, int, tree, tree, tree);
44 static tree split_conversions (tree, tree, tree, tree);
45 static int lookup_conversions_r (tree, int, int,
46 tree, tree, tree, tree, tree *, tree *);
47 static int look_for_overrides_r (tree, tree);
48 static tree lookup_field_r (tree, void *);
49 static tree dfs_accessible_post (tree, void *);
50 static tree dfs_walk_once_accessible_r (tree, bool, bool,
51 tree (*pre_fn) (tree, void *),
52 tree (*post_fn) (tree, void *),
54 static tree dfs_walk_once_accessible (tree, bool,
55 tree (*pre_fn) (tree, void *),
56 tree (*post_fn) (tree, void *),
58 static tree dfs_access_in_type (tree, void *);
59 static access_kind access_in_type (tree, tree);
60 static int protected_accessible_p (tree, tree, tree);
61 static int friend_accessible_p (tree, tree, tree);
62 static tree dfs_get_pure_virtuals (tree, void *);
65 /* Variables for gathering statistics. */
66 static int n_fields_searched;
67 static int n_calls_lookup_field, n_calls_lookup_field_1;
68 static int n_calls_lookup_fnfields, n_calls_lookup_fnfields_1;
69 static int n_calls_get_base_type;
70 static int n_outer_fields_searched;
71 static int n_contexts_saved;
74 /* Data for lookup_base and its workers. */
76 struct lookup_base_data_s
78 tree t; /* type being searched. */
79 tree base; /* The base type we're looking for. */
80 tree binfo; /* Found binfo. */
81 bool via_virtual; /* Found via a virtual path. */
82 bool ambiguous; /* Found multiply ambiguous */
83 bool repeated_base; /* Whether there are repeated bases in the
85 bool want_any; /* Whether we want any matching binfo. */
88 /* Worker function for lookup_base. See if we've found the desired
89 base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
92 dfs_lookup_base (tree binfo, void *data_)
94 struct lookup_base_data_s *data = (struct lookup_base_data_s *) data_;
96 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->base))
102 = binfo_via_virtual (data->binfo, data->t) != NULL_TREE;
104 if (!data->repeated_base)
105 /* If there are no repeated bases, we can stop now. */
108 if (data->want_any && !data->via_virtual)
109 /* If this is a non-virtual base, then we can't do
113 return dfs_skip_bases;
117 gcc_assert (binfo != data->binfo);
119 /* We've found more than one matching binfo. */
122 /* This is immediately ambiguous. */
123 data->binfo = NULL_TREE;
124 data->ambiguous = true;
125 return error_mark_node;
128 /* Prefer one via a non-virtual path. */
129 if (!binfo_via_virtual (binfo, data->t))
132 data->via_virtual = false;
136 /* There must be repeated bases, otherwise we'd have stopped
137 on the first base we found. */
138 return dfs_skip_bases;
145 /* Returns true if type BASE is accessible in T. (BASE is known to be
146 a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
147 true, consider any special access of the current scope, or access
148 bestowed by friendship. */
151 accessible_base_p (tree t, tree base, bool consider_local_p)
155 /* [class.access.base]
157 A base class is said to be accessible if an invented public
158 member of the base class is accessible.
160 If BASE is a non-proper base, this condition is trivially
162 if (same_type_p (t, base))
164 /* Rather than inventing a public member, we use the implicit
165 public typedef created in the scope of every class. */
166 decl = TYPE_FIELDS (base);
167 while (!DECL_SELF_REFERENCE_P (decl))
168 decl = DECL_CHAIN (decl);
169 while (ANON_AGGR_TYPE_P (t))
170 t = TYPE_CONTEXT (t);
171 return accessible_p (t, decl, consider_local_p);
174 /* Lookup BASE in the hierarchy dominated by T. Do access checking as
175 ACCESS specifies. Return the binfo we discover. If KIND_PTR is
176 non-NULL, fill with information about what kind of base we
179 If the base is inaccessible, or ambiguous, then error_mark_node is
180 returned. If the tf_error bit of COMPLAIN is not set, no error
184 lookup_base (tree t, tree base, base_access access,
185 base_kind *kind_ptr, tsubst_flags_t complain)
191 /* "Nothing" is definitely not derived from Base. */
195 *kind_ptr = bk_not_base;
199 if (t == error_mark_node || base == error_mark_node)
202 *kind_ptr = bk_not_base;
203 return error_mark_node;
205 gcc_assert (TYPE_P (base));
214 t = complete_type (TYPE_MAIN_VARIANT (t));
215 t_binfo = TYPE_BINFO (t);
218 base = TYPE_MAIN_VARIANT (base);
220 /* If BASE is incomplete, it can't be a base of T--and instantiating it
221 might cause an error. */
222 if (t_binfo && CLASS_TYPE_P (base) && COMPLETE_OR_OPEN_TYPE_P (base))
224 struct lookup_base_data_s data;
228 data.binfo = NULL_TREE;
229 data.ambiguous = data.via_virtual = false;
230 data.repeated_base = CLASSTYPE_REPEATED_BASE_P (t);
231 data.want_any = access == ba_any;
233 dfs_walk_once (t_binfo, dfs_lookup_base, NULL, &data);
237 bk = data.ambiguous ? bk_ambig : bk_not_base;
238 else if (binfo == t_binfo)
240 else if (data.via_virtual)
251 /* Check that the base is unambiguous and accessible. */
252 if (access != ba_any)
259 if (complain & tf_error)
260 error ("%qT is an ambiguous base of %qT", base, t);
261 binfo = error_mark_node;
265 if ((access & ba_check_bit)
266 /* If BASE is incomplete, then BASE and TYPE are probably
267 the same, in which case BASE is accessible. If they
268 are not the same, then TYPE is invalid. In that case,
269 there's no need to issue another error here, and
270 there's no implicit typedef to use in the code that
271 follows, so we skip the check. */
272 && COMPLETE_TYPE_P (base)
273 && !accessible_base_p (t, base, !(access & ba_ignore_scope)))
275 if (complain & tf_error)
276 error ("%qT is an inaccessible base of %qT", base, t);
277 binfo = error_mark_node;
278 bk = bk_inaccessible;
289 /* Data for dcast_base_hint walker. */
293 tree subtype; /* The base type we're looking for. */
294 int virt_depth; /* Number of virtual bases encountered from most
296 tree offset; /* Best hint offset discovered so far. */
297 bool repeated_base; /* Whether there are repeated bases in the
301 /* Worker for dcast_base_hint. Search for the base type being cast
305 dfs_dcast_hint_pre (tree binfo, void *data_)
307 struct dcast_data_s *data = (struct dcast_data_s *) data_;
309 if (BINFO_VIRTUAL_P (binfo))
312 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->subtype))
314 if (data->virt_depth)
316 data->offset = ssize_int (-1);
320 data->offset = ssize_int (-3);
322 data->offset = BINFO_OFFSET (binfo);
324 return data->repeated_base ? dfs_skip_bases : data->offset;
330 /* Worker for dcast_base_hint. Track the virtual depth. */
333 dfs_dcast_hint_post (tree binfo, void *data_)
335 struct dcast_data_s *data = (struct dcast_data_s *) data_;
337 if (BINFO_VIRTUAL_P (binfo))
343 /* The dynamic cast runtime needs a hint about how the static SUBTYPE type
344 started from is related to the required TARGET type, in order to optimize
345 the inheritance graph search. This information is independent of the
346 current context, and ignores private paths, hence get_base_distance is
347 inappropriate. Return a TREE specifying the base offset, BOFF.
348 BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
349 and there are no public virtual SUBTYPE bases.
350 BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
351 BOFF == -2, SUBTYPE is not a public base.
352 BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
355 dcast_base_hint (tree subtype, tree target)
357 struct dcast_data_s data;
359 data.subtype = subtype;
361 data.offset = NULL_TREE;
362 data.repeated_base = CLASSTYPE_REPEATED_BASE_P (target);
364 dfs_walk_once_accessible (TYPE_BINFO (target), /*friends=*/false,
365 dfs_dcast_hint_pre, dfs_dcast_hint_post, &data);
366 return data.offset ? data.offset : ssize_int (-2);
369 /* Search for a member with name NAME in a multiple inheritance
370 lattice specified by TYPE. If it does not exist, return NULL_TREE.
371 If the member is ambiguously referenced, return `error_mark_node'.
372 Otherwise, return a DECL with the indicated name. If WANT_TYPE is
373 true, type declarations are preferred. */
375 /* Do a 1-level search for NAME as a member of TYPE. The caller must
376 figure out whether it can access this field. (Since it is only one
377 level, this is reasonable.) */
380 lookup_field_1 (tree type, tree name, bool want_type)
384 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
386 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
387 || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
388 || TREE_CODE (type) == TYPENAME_TYPE)
389 /* The TYPE_FIELDS of a TEMPLATE_TYPE_PARM and
390 BOUND_TEMPLATE_TEMPLATE_PARM are not fields at all;
391 instead TYPE_FIELDS is the TEMPLATE_PARM_INDEX. (Miraculously,
392 the code often worked even when we treated the index as a list
394 The TYPE_FIELDS of TYPENAME_TYPE is its TYPENAME_TYPE_FULLNAME. */
397 if (CLASSTYPE_SORTED_FIELDS (type))
399 tree *fields = &CLASSTYPE_SORTED_FIELDS (type)->elts[0];
400 int lo = 0, hi = CLASSTYPE_SORTED_FIELDS (type)->len;
407 if (GATHER_STATISTICS)
410 if (DECL_NAME (fields[i]) > name)
412 else if (DECL_NAME (fields[i]) < name)
418 /* We might have a nested class and a field with the
419 same name; we sorted them appropriately via
420 field_decl_cmp, so just look for the first or last
421 field with this name. */
426 while (i >= lo && DECL_NAME (fields[i]) == name);
427 if (TREE_CODE (field) != TYPE_DECL
428 && !DECL_TYPE_TEMPLATE_P (field))
435 while (i < hi && DECL_NAME (fields[i]) == name);
440 field = strip_using_decl (field);
441 if (is_overloaded_fn (field))
451 field = TYPE_FIELDS (type);
453 if (GATHER_STATISTICS)
454 n_calls_lookup_field_1++;
456 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
460 if (GATHER_STATISTICS)
463 gcc_assert (DECL_P (field));
464 if (DECL_NAME (field) == NULL_TREE
465 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
467 tree temp = lookup_field_1 (TREE_TYPE (field), name, want_type);
472 if (TREE_CODE (decl) == USING_DECL
473 && DECL_NAME (decl) == name)
475 decl = strip_using_decl (decl);
476 if (is_overloaded_fn (decl))
480 if (DECL_NAME (decl) == name
482 || TREE_CODE (decl) == TYPE_DECL
483 || DECL_TYPE_TEMPLATE_P (decl)))
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 /* Also check cfun to make sure that we're really compiling
541 this function (as opposed to having set current_function_decl
542 for access checking or some such). */
543 return (cs && TREE_CODE (cs) == FUNCTION_DECL
544 && cfun && cfun->decl == current_function_decl);
547 /* Returns true if the innermost active scope is a class scope. */
550 at_class_scope_p (void)
552 tree cs = current_scope ();
553 return cs && TYPE_P (cs);
556 /* Returns true if the innermost active scope is a namespace scope. */
559 at_namespace_scope_p (void)
561 tree cs = current_scope ();
562 return cs && TREE_CODE (cs) == NAMESPACE_DECL;
565 /* Return the scope of DECL, as appropriate when doing name-lookup. */
568 context_for_name_lookup (tree decl)
572 For the purposes of name lookup, after the anonymous union
573 definition, the members of the anonymous union are considered to
574 have been defined in the scope in which the anonymous union is
576 tree context = DECL_CONTEXT (decl);
578 while (context && TYPE_P (context)
579 && (ANON_AGGR_TYPE_P (context) || UNSCOPED_ENUM_P (context)))
580 context = TYPE_CONTEXT (context);
582 context = global_namespace;
587 /* The accessibility routines use BINFO_ACCESS for scratch space
588 during the computation of the accessibility of some declaration. */
590 #define BINFO_ACCESS(NODE) \
591 ((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE)))
593 /* Set the access associated with NODE to ACCESS. */
595 #define SET_BINFO_ACCESS(NODE, ACCESS) \
596 ((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \
597 (TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0))
599 /* Called from access_in_type via dfs_walk. Calculate the access to
600 DATA (which is really a DECL) in BINFO. */
603 dfs_access_in_type (tree binfo, void *data)
605 tree decl = (tree) data;
606 tree type = BINFO_TYPE (binfo);
607 access_kind access = ak_none;
609 if (context_for_name_lookup (decl) == type)
611 /* If we have descended to the scope of DECL, just note the
612 appropriate access. */
613 if (TREE_PRIVATE (decl))
615 else if (TREE_PROTECTED (decl))
616 access = ak_protected;
622 /* First, check for an access-declaration that gives us more
623 access to the DECL. */
624 if (DECL_LANG_SPECIFIC (decl) && !DECL_DISCRIMINATOR_P (decl))
626 tree decl_access = purpose_member (type, DECL_ACCESS (decl));
630 decl_access = TREE_VALUE (decl_access);
632 if (decl_access == access_public_node)
634 else if (decl_access == access_protected_node)
635 access = ak_protected;
636 else if (decl_access == access_private_node)
647 vec<tree, va_gc> *accesses;
649 /* Otherwise, scan our baseclasses, and pick the most favorable
651 accesses = BINFO_BASE_ACCESSES (binfo);
652 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
654 tree base_access = (*accesses)[i];
655 access_kind base_access_now = BINFO_ACCESS (base_binfo);
657 if (base_access_now == ak_none || base_access_now == ak_private)
658 /* If it was not accessible in the base, or only
659 accessible as a private member, we can't access it
661 base_access_now = ak_none;
662 else if (base_access == access_protected_node)
663 /* Public and protected members in the base become
665 base_access_now = ak_protected;
666 else if (base_access == access_private_node)
667 /* Public and protected members in the base become
669 base_access_now = ak_private;
671 /* See if the new access, via this base, gives more
672 access than our previous best access. */
673 if (base_access_now != ak_none
674 && (access == ak_none || base_access_now < access))
676 access = base_access_now;
678 /* If the new access is public, we can't do better. */
679 if (access == ak_public)
686 /* Note the access to DECL in TYPE. */
687 SET_BINFO_ACCESS (binfo, access);
692 /* Return the access to DECL in TYPE. */
695 access_in_type (tree type, tree decl)
697 tree binfo = TYPE_BINFO (type);
699 /* We must take into account
703 If a name can be reached by several paths through a multiple
704 inheritance graph, the access is that of the path that gives
707 The algorithm we use is to make a post-order depth-first traversal
708 of the base-class hierarchy. As we come up the tree, we annotate
709 each node with the most lenient access. */
710 dfs_walk_once (binfo, NULL, dfs_access_in_type, decl);
712 return BINFO_ACCESS (binfo);
715 /* Returns nonzero if it is OK to access DECL through an object
716 indicated by BINFO in the context of DERIVED. */
719 protected_accessible_p (tree decl, tree derived, tree binfo)
723 /* We're checking this clause from [class.access.base]
725 m as a member of N is protected, and the reference occurs in a
726 member or friend of class N, or in a member or friend of a
727 class P derived from N, where m as a member of P is public, private
730 Here DERIVED is a possible P, DECL is m and BINFO_TYPE (binfo) is N. */
732 /* If DERIVED isn't derived from N, then it can't be a P. */
733 if (!DERIVED_FROM_P (BINFO_TYPE (binfo), derived))
736 access = access_in_type (derived, decl);
738 /* If m is inaccessible in DERIVED, then it's not a P. */
739 if (access == ak_none)
744 When a friend or a member function of a derived class references
745 a protected nonstatic member of a base class, an access check
746 applies in addition to those described earlier in clause
747 _class.access_) Except when forming a pointer to member
748 (_expr.unary.op_), the access must be through a pointer to,
749 reference to, or object of the derived class itself (or any class
750 derived from that class) (_expr.ref_). If the access is to form
751 a pointer to member, the nested-name-specifier shall name the
752 derived class (or any class derived from that class). */
753 if (DECL_NONSTATIC_MEMBER_P (decl))
755 /* We can tell through what the reference is occurring by
756 chasing BINFO up to the root. */
758 while (BINFO_INHERITANCE_CHAIN (t))
759 t = BINFO_INHERITANCE_CHAIN (t);
761 if (!DERIVED_FROM_P (derived, BINFO_TYPE (t)))
768 /* Returns nonzero if SCOPE is a friend of a type which would be able
769 to access DECL through the object indicated by BINFO. */
772 friend_accessible_p (tree scope, tree decl, tree binfo)
774 tree befriending_classes;
780 if (TREE_CODE (scope) == FUNCTION_DECL
781 || DECL_FUNCTION_TEMPLATE_P (scope))
782 befriending_classes = DECL_BEFRIENDING_CLASSES (scope);
783 else if (TYPE_P (scope))
784 befriending_classes = CLASSTYPE_BEFRIENDING_CLASSES (scope);
788 for (t = befriending_classes; t; t = TREE_CHAIN (t))
789 if (protected_accessible_p (decl, TREE_VALUE (t), binfo))
792 /* Nested classes have the same access as their enclosing types, as
793 per DR 45 (this is a change from the standard). */
795 for (t = TYPE_CONTEXT (scope); t && TYPE_P (t); t = TYPE_CONTEXT (t))
796 if (protected_accessible_p (decl, t, binfo))
799 if (TREE_CODE (scope) == FUNCTION_DECL
800 || DECL_FUNCTION_TEMPLATE_P (scope))
802 /* Perhaps this SCOPE is a member of a class which is a
804 if (DECL_CLASS_SCOPE_P (scope)
805 && friend_accessible_p (DECL_CONTEXT (scope), decl, binfo))
808 /* Or an instantiation of something which is a friend. */
809 if (DECL_TEMPLATE_INFO (scope))
812 /* Increment processing_template_decl to make sure that
813 dependent_type_p works correctly. */
814 ++processing_template_decl;
815 ret = friend_accessible_p (DECL_TI_TEMPLATE (scope), decl, binfo);
816 --processing_template_decl;
824 /* Called via dfs_walk_once_accessible from accessible_p */
827 dfs_accessible_post (tree binfo, void * /*data*/)
829 if (BINFO_ACCESS (binfo) != ak_none)
831 tree scope = current_scope ();
832 if (scope && TREE_CODE (scope) != NAMESPACE_DECL
833 && is_friend (BINFO_TYPE (binfo), scope))
840 /* Like accessible_p below, but within a template returns true iff DECL is
841 accessible in TYPE to all possible instantiations of the template. */
844 accessible_in_template_p (tree type, tree decl)
846 int save_ptd = processing_template_decl;
847 processing_template_decl = 0;
848 int val = accessible_p (type, decl, false);
849 processing_template_decl = save_ptd;
853 /* DECL is a declaration from a base class of TYPE, which was the
854 class used to name DECL. Return nonzero if, in the current
855 context, DECL is accessible. If TYPE is actually a BINFO node,
856 then we can tell in what context the access is occurring by looking
857 at the most derived class along the path indicated by BINFO. If
858 CONSIDER_LOCAL is true, do consider special access the current
859 scope or friendship thereof we might have. */
862 accessible_p (tree type, tree decl, bool consider_local_p)
868 /* Nonzero if it's OK to access DECL if it has protected
869 accessibility in TYPE. */
870 int protected_ok = 0;
872 /* If this declaration is in a block or namespace scope, there's no
874 if (!TYPE_P (context_for_name_lookup (decl)))
877 /* There is no need to perform access checks inside a thunk. */
878 scope = current_scope ();
879 if (scope && DECL_THUNK_P (scope))
882 /* In a template declaration, we cannot be sure whether the
883 particular specialization that is instantiated will be a friend
884 or not. Therefore, all access checks are deferred until
885 instantiation. However, PROCESSING_TEMPLATE_DECL is set in the
886 parameter list for a template (because we may see dependent types
887 in default arguments for template parameters), and access
888 checking should be performed in the outermost parameter list. */
889 if (processing_template_decl
890 && (!processing_template_parmlist || processing_template_decl > 1))
896 type = BINFO_TYPE (type);
899 binfo = TYPE_BINFO (type);
901 /* [class.access.base]
903 A member m is accessible when named in class N if
905 --m as a member of N is public, or
907 --m as a member of N is private, and the reference occurs in a
908 member or friend of class N, or
910 --m as a member of N is protected, and the reference occurs in a
911 member or friend of class N, or in a member or friend of a
912 class P derived from N, where m as a member of P is private or
915 --there exists a base class B of N that is accessible at the point
916 of reference, and m is accessible when named in class B.
918 We walk the base class hierarchy, checking these conditions. */
920 if (consider_local_p)
922 /* Figure out where the reference is occurring. Check to see if
923 DECL is private or protected in this scope, since that will
924 determine whether protected access is allowed. */
925 if (current_class_type)
926 protected_ok = protected_accessible_p (decl,
927 current_class_type, binfo);
929 /* Now, loop through the classes of which we are a friend. */
931 protected_ok = friend_accessible_p (scope, decl, binfo);
934 /* Standardize the binfo that access_in_type will use. We don't
935 need to know what path was chosen from this point onwards. */
936 binfo = TYPE_BINFO (type);
938 /* Compute the accessibility of DECL in the class hierarchy
939 dominated by type. */
940 access = access_in_type (type, decl);
941 if (access == ak_public
942 || (access == ak_protected && protected_ok))
945 if (!consider_local_p)
948 /* Walk the hierarchy again, looking for a base class that allows
950 return dfs_walk_once_accessible (binfo, /*friends=*/true,
951 NULL, dfs_accessible_post, NULL)
955 struct lookup_field_info {
956 /* The type in which we're looking. */
958 /* The name of the field for which we're looking. */
960 /* If non-NULL, the current result of the lookup. */
962 /* The path to RVAL. */
964 /* If non-NULL, the lookup was ambiguous, and this is a list of the
967 /* If nonzero, we are looking for types, not data members. */
969 /* If something went wrong, a message indicating what. */
973 /* Nonzero for a class member means that it is shared between all objects
976 [class.member.lookup]:If the resulting set of declarations are not all
977 from sub-objects of the same type, or the set has a nonstatic member
978 and includes members from distinct sub-objects, there is an ambiguity
979 and the program is ill-formed.
981 This function checks that T contains no nonstatic members. */
984 shared_member_p (tree t)
986 if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == TYPE_DECL \
987 || TREE_CODE (t) == CONST_DECL)
989 if (is_overloaded_fn (t))
992 for (; t; t = OVL_NEXT (t))
994 tree fn = OVL_CURRENT (t);
995 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1003 /* Routine to see if the sub-object denoted by the binfo PARENT can be
1004 found as a base class and sub-object of the object denoted by
1008 is_subobject_of_p (tree parent, tree binfo)
1012 for (probe = parent; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1016 if (BINFO_VIRTUAL_P (probe))
1017 return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (binfo))
1023 /* DATA is really a struct lookup_field_info. Look for a field with
1024 the name indicated there in BINFO. If this function returns a
1025 non-NULL value it is the result of the lookup. Called from
1026 lookup_field via breadth_first_search. */
1029 lookup_field_r (tree binfo, void *data)
1031 struct lookup_field_info *lfi = (struct lookup_field_info *) data;
1032 tree type = BINFO_TYPE (binfo);
1033 tree nval = NULL_TREE;
1035 /* If this is a dependent base, don't look in it. */
1036 if (BINFO_DEPENDENT_BASE_P (binfo))
1039 /* If this base class is hidden by the best-known value so far, we
1040 don't need to look. */
1041 if (lfi->rval_binfo && BINFO_INHERITANCE_CHAIN (binfo) == lfi->rval_binfo
1042 && !BINFO_VIRTUAL_P (binfo))
1043 return dfs_skip_bases;
1045 /* First, look for a function. There can't be a function and a data
1046 member with the same name, and if there's a function and a type
1047 with the same name, the type is hidden by the function. */
1048 if (!lfi->want_type)
1049 nval = lookup_fnfields_slot (type, lfi->name);
1052 /* Look for a data member or type. */
1053 nval = lookup_field_1 (type, lfi->name, lfi->want_type);
1055 /* If there is no declaration with the indicated name in this type,
1056 then there's nothing to do. */
1060 /* If we're looking up a type (as with an elaborated type specifier)
1061 we ignore all non-types we find. */
1062 if (lfi->want_type && TREE_CODE (nval) != TYPE_DECL
1063 && !DECL_TYPE_TEMPLATE_P (nval))
1065 if (lfi->name == TYPE_IDENTIFIER (type))
1067 /* If the aggregate has no user defined constructors, we allow
1068 it to have fields with the same name as the enclosing type.
1069 If we are looking for that name, find the corresponding
1071 for (nval = TREE_CHAIN (nval); nval; nval = TREE_CHAIN (nval))
1072 if (DECL_NAME (nval) == lfi->name
1073 && TREE_CODE (nval) == TYPE_DECL)
1078 if (!nval && CLASSTYPE_NESTED_UTDS (type) != NULL)
1080 binding_entry e = binding_table_find (CLASSTYPE_NESTED_UTDS (type),
1083 nval = TYPE_MAIN_DECL (e->type);
1089 /* If the lookup already found a match, and the new value doesn't
1090 hide the old one, we might have an ambiguity. */
1092 && !is_subobject_of_p (lfi->rval_binfo, binfo))
1095 if (nval == lfi->rval && shared_member_p (nval))
1096 /* The two things are really the same. */
1098 else if (is_subobject_of_p (binfo, lfi->rval_binfo))
1099 /* The previous value hides the new one. */
1103 /* We have a real ambiguity. We keep a chain of all the
1105 if (!lfi->ambiguous && lfi->rval)
1107 /* This is the first time we noticed an ambiguity. Add
1108 what we previously thought was a reasonable candidate
1110 lfi->ambiguous = tree_cons (NULL_TREE, lfi->rval, NULL_TREE);
1111 TREE_TYPE (lfi->ambiguous) = error_mark_node;
1114 /* Add the new value. */
1115 lfi->ambiguous = tree_cons (NULL_TREE, nval, lfi->ambiguous);
1116 TREE_TYPE (lfi->ambiguous) = error_mark_node;
1117 lfi->errstr = G_("request for member %qD is ambiguous");
1123 lfi->rval_binfo = binfo;
1127 /* Don't look for constructors or destructors in base classes. */
1128 if (IDENTIFIER_CTOR_OR_DTOR_P (lfi->name))
1129 return dfs_skip_bases;
1133 /* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO,
1134 BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO,
1135 FUNCTIONS, and OPTYPE respectively. */
1138 build_baselink (tree binfo, tree access_binfo, tree functions, tree optype)
1142 gcc_assert (TREE_CODE (functions) == FUNCTION_DECL
1143 || TREE_CODE (functions) == TEMPLATE_DECL
1144 || TREE_CODE (functions) == TEMPLATE_ID_EXPR
1145 || TREE_CODE (functions) == OVERLOAD);
1146 gcc_assert (!optype || TYPE_P (optype));
1147 gcc_assert (TREE_TYPE (functions));
1149 baselink = make_node (BASELINK);
1150 TREE_TYPE (baselink) = TREE_TYPE (functions);
1151 BASELINK_BINFO (baselink) = binfo;
1152 BASELINK_ACCESS_BINFO (baselink) = access_binfo;
1153 BASELINK_FUNCTIONS (baselink) = functions;
1154 BASELINK_OPTYPE (baselink) = optype;
1159 /* Look for a member named NAME in an inheritance lattice dominated by
1160 XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
1161 is 1, we enforce accessibility. If PROTECT is zero, then, for an
1162 ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
1163 messages about inaccessible or ambiguous lookup. If PROTECT is 2,
1164 we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
1165 TREE_VALUEs are the list of ambiguous candidates.
1167 WANT_TYPE is 1 when we should only return TYPE_DECLs.
1169 If nothing can be found return NULL_TREE and do not issue an error. */
1172 lookup_member (tree xbasetype, tree name, int protect, bool want_type,
1173 tsubst_flags_t complain)
1175 tree rval, rval_binfo = NULL_TREE;
1176 tree type = NULL_TREE, basetype_path = NULL_TREE;
1177 struct lookup_field_info lfi;
1179 /* rval_binfo is the binfo associated with the found member, note,
1180 this can be set with useful information, even when rval is not
1181 set, because it must deal with ALL members, not just non-function
1182 members. It is used for ambiguity checking and the hidden
1183 checks. Whereas rval is only set if a proper (not hidden)
1184 non-function member is found. */
1186 const char *errstr = 0;
1188 if (name == error_mark_node
1189 || xbasetype == NULL_TREE
1190 || xbasetype == error_mark_node)
1193 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1195 if (TREE_CODE (xbasetype) == TREE_BINFO)
1197 type = BINFO_TYPE (xbasetype);
1198 basetype_path = xbasetype;
1202 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype)))
1205 xbasetype = NULL_TREE;
1208 type = complete_type (type);
1210 basetype_path = TYPE_BINFO (type);
1215 if (GATHER_STATISTICS)
1216 n_calls_lookup_field++;
1218 memset (&lfi, 0, sizeof (lfi));
1221 lfi.want_type = want_type;
1222 dfs_walk_all (basetype_path, &lookup_field_r, NULL, &lfi);
1224 rval_binfo = lfi.rval_binfo;
1226 type = BINFO_TYPE (rval_binfo);
1227 errstr = lfi.errstr;
1229 /* If we are not interested in ambiguities, don't report them;
1230 just return NULL_TREE. */
1231 if (!protect && lfi.ambiguous)
1237 return lfi.ambiguous;
1244 In the case of overloaded function names, access control is
1245 applied to the function selected by overloaded resolution.
1247 We cannot check here, even if RVAL is only a single non-static
1248 member function, since we do not know what the "this" pointer
1251 class A { protected: void f(); };
1252 class B : public A {
1259 only the first call to "f" is valid. However, if the function is
1260 static, we can check. */
1262 && !really_overloaded_fn (rval))
1264 tree decl = is_overloaded_fn (rval) ? get_first_fn (rval) : rval;
1265 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
1266 && !perform_or_defer_access_check (basetype_path, decl, decl,
1268 rval = error_mark_node;
1271 if (errstr && protect)
1273 if (complain & tf_error)
1275 error (errstr, name, type);
1277 print_candidates (lfi.ambiguous);
1279 rval = error_mark_node;
1282 if (rval && is_overloaded_fn (rval))
1283 rval = build_baselink (rval_binfo, basetype_path, rval,
1284 (IDENTIFIER_TYPENAME_P (name)
1285 ? TREE_TYPE (name): NULL_TREE));
1289 /* Like lookup_member, except that if we find a function member we
1290 return NULL_TREE. */
1293 lookup_field (tree xbasetype, tree name, int protect, bool want_type)
1295 tree rval = lookup_member (xbasetype, name, protect, want_type,
1296 tf_warning_or_error);
1298 /* Ignore functions, but propagate the ambiguity list. */
1299 if (!error_operand_p (rval)
1300 && (rval && BASELINK_P (rval)))
1306 /* Like lookup_member, except that if we find a non-function member we
1307 return NULL_TREE. */
1310 lookup_fnfields (tree xbasetype, tree name, int protect)
1312 tree rval = lookup_member (xbasetype, name, protect, /*want_type=*/false,
1313 tf_warning_or_error);
1315 /* Ignore non-functions, but propagate the ambiguity list. */
1316 if (!error_operand_p (rval)
1317 && (rval && !BASELINK_P (rval)))
1323 /* Return the index in the CLASSTYPE_METHOD_VEC for CLASS_TYPE
1324 corresponding to "operator TYPE ()", or -1 if there is no such
1325 operator. Only CLASS_TYPE itself is searched; this routine does
1326 not scan the base classes of CLASS_TYPE. */
1329 lookup_conversion_operator (tree class_type, tree type)
1333 if (TYPE_HAS_CONVERSION (class_type))
1337 vec<tree, va_gc> *methods = CLASSTYPE_METHOD_VEC (class_type);
1339 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
1340 vec_safe_iterate (methods, i, &fn); ++i)
1342 /* All the conversion operators come near the beginning of
1343 the class. Therefore, if FN is not a conversion
1344 operator, there is no matching conversion operator in
1346 fn = OVL_CURRENT (fn);
1347 if (!DECL_CONV_FN_P (fn))
1350 if (TREE_CODE (fn) == TEMPLATE_DECL)
1351 /* All the templated conversion functions are on the same
1352 slot, so remember it. */
1354 else if (same_type_p (DECL_CONV_FN_TYPE (fn), type))
1362 /* TYPE is a class type. Return the index of the fields within
1363 the method vector with name NAME, or -1 if no such field exists.
1364 Does not lazily declare implicitly-declared member functions. */
1367 lookup_fnfields_idx_nolazy (tree type, tree name)
1369 vec<tree, va_gc> *method_vec;
1374 if (!CLASS_TYPE_P (type))
1377 method_vec = CLASSTYPE_METHOD_VEC (type);
1381 if (GATHER_STATISTICS)
1382 n_calls_lookup_fnfields_1++;
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_safe_iterate (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 = method_vec->length ();
1418 if (GATHER_STATISTICS)
1419 n_outer_fields_searched++;
1421 tmp = (*method_vec)[i];
1422 tmp = DECL_NAME (OVL_CURRENT (tmp));
1425 else if (tmp < name)
1432 for (; vec_safe_iterate (method_vec, i, &fn); ++i)
1434 if (GATHER_STATISTICS)
1435 n_outer_fields_searched++;
1436 if (DECL_NAME (OVL_CURRENT (fn)) == name)
1443 /* TYPE is a class type. Return the index of the fields within
1444 the method vector with name NAME, or -1 if no such field exists. */
1447 lookup_fnfields_1 (tree type, tree name)
1449 if (!CLASS_TYPE_P (type))
1452 if (COMPLETE_TYPE_P (type))
1454 if ((name == ctor_identifier
1455 || name == base_ctor_identifier
1456 || name == complete_ctor_identifier))
1458 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type))
1459 lazily_declare_fn (sfk_constructor, type);
1460 if (CLASSTYPE_LAZY_COPY_CTOR (type))
1461 lazily_declare_fn (sfk_copy_constructor, type);
1462 if (CLASSTYPE_LAZY_MOVE_CTOR (type))
1463 lazily_declare_fn (sfk_move_constructor, type);
1465 else if (name == ansi_assopname (NOP_EXPR))
1467 if (CLASSTYPE_LAZY_COPY_ASSIGN (type))
1468 lazily_declare_fn (sfk_copy_assignment, type);
1469 if (CLASSTYPE_LAZY_MOVE_ASSIGN (type))
1470 lazily_declare_fn (sfk_move_assignment, type);
1472 else if ((name == dtor_identifier
1473 || name == base_dtor_identifier
1474 || name == complete_dtor_identifier
1475 || name == deleting_dtor_identifier)
1476 && CLASSTYPE_LAZY_DESTRUCTOR (type))
1477 lazily_declare_fn (sfk_destructor, type);
1480 return lookup_fnfields_idx_nolazy (type, name);
1483 /* TYPE is a class type. Return the field within the method vector with
1484 name NAME, or NULL_TREE if no such field exists. */
1487 lookup_fnfields_slot (tree type, tree name)
1489 int ix = lookup_fnfields_1 (complete_type (type), name);
1492 return (*CLASSTYPE_METHOD_VEC (type))[ix];
1495 /* As above, but avoid lazily declaring functions. */
1498 lookup_fnfields_slot_nolazy (tree type, tree name)
1500 int ix = lookup_fnfields_idx_nolazy (complete_type (type), name);
1503 return (*CLASSTYPE_METHOD_VEC (type))[ix];
1506 /* Like lookup_fnfields_1, except that the name is extracted from
1507 FUNCTION, which is a FUNCTION_DECL or a TEMPLATE_DECL. */
1510 class_method_index_for_fn (tree class_type, tree function)
1512 gcc_assert (TREE_CODE (function) == FUNCTION_DECL
1513 || DECL_FUNCTION_TEMPLATE_P (function));
1515 return lookup_fnfields_1 (class_type,
1516 DECL_CONSTRUCTOR_P (function) ? ctor_identifier :
1517 DECL_DESTRUCTOR_P (function) ? dtor_identifier :
1518 DECL_NAME (function));
1522 /* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
1523 the class or namespace used to qualify the name. CONTEXT_CLASS is
1524 the class corresponding to the object in which DECL will be used.
1525 Return a possibly modified version of DECL that takes into account
1528 In particular, consider an expression like `B::m' in the context of
1529 a derived class `D'. If `B::m' has been resolved to a BASELINK,
1530 then the most derived class indicated by the BASELINK_BINFO will be
1531 `B', not `D'. This function makes that adjustment. */
1534 adjust_result_of_qualified_name_lookup (tree decl,
1535 tree qualifying_scope,
1538 if (context_class && context_class != error_mark_node
1539 && CLASS_TYPE_P (context_class)
1540 && CLASS_TYPE_P (qualifying_scope)
1541 && DERIVED_FROM_P (qualifying_scope, context_class)
1542 && BASELINK_P (decl))
1546 /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
1547 Because we do not yet know which function will be chosen by
1548 overload resolution, we cannot yet check either accessibility
1549 or ambiguity -- in either case, the choice of a static member
1550 function might make the usage valid. */
1551 base = lookup_base (context_class, qualifying_scope,
1552 ba_unique, NULL, tf_none);
1553 if (base && base != error_mark_node)
1555 BASELINK_ACCESS_BINFO (decl) = base;
1556 BASELINK_BINFO (decl)
1557 = lookup_base (base, BINFO_TYPE (BASELINK_BINFO (decl)),
1558 ba_unique, NULL, tf_none);
1562 if (BASELINK_P (decl))
1563 BASELINK_QUALIFIED_P (decl) = true;
1569 /* Walk the class hierarchy within BINFO, in a depth-first traversal.
1570 PRE_FN is called in preorder, while POST_FN is called in postorder.
1571 If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
1572 walked. If PRE_FN or POST_FN returns a different non-NULL value,
1573 that value is immediately returned and the walk is terminated. One
1574 of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
1575 POST_FN are passed the binfo to examine and the caller's DATA
1576 value. All paths are walked, thus virtual and morally virtual
1577 binfos can be multiply walked. */
1580 dfs_walk_all (tree binfo, tree (*pre_fn) (tree, void *),
1581 tree (*post_fn) (tree, void *), void *data)
1587 /* Call the pre-order walking function. */
1590 rval = pre_fn (binfo, data);
1593 if (rval == dfs_skip_bases)
1599 /* Find the next child binfo to walk. */
1600 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1602 rval = dfs_walk_all (base_binfo, pre_fn, post_fn, data);
1608 /* Call the post-order walking function. */
1611 rval = post_fn (binfo, data);
1612 gcc_assert (rval != dfs_skip_bases);
1619 /* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1620 that binfos are walked at most once. */
1623 dfs_walk_once_r (tree binfo, tree (*pre_fn) (tree, void *),
1624 tree (*post_fn) (tree, void *), void *data)
1630 /* Call the pre-order walking function. */
1633 rval = pre_fn (binfo, data);
1636 if (rval == dfs_skip_bases)
1643 /* Find the next child binfo to walk. */
1644 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1646 if (BINFO_VIRTUAL_P (base_binfo))
1648 if (BINFO_MARKED (base_binfo))
1650 BINFO_MARKED (base_binfo) = 1;
1653 rval = dfs_walk_once_r (base_binfo, pre_fn, post_fn, data);
1659 /* Call the post-order walking function. */
1662 rval = post_fn (binfo, data);
1663 gcc_assert (rval != dfs_skip_bases);
1670 /* Worker for dfs_walk_once. Recursively unmark the virtual base binfos of
1674 dfs_unmark_r (tree binfo)
1679 /* Process the basetypes. */
1680 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1682 if (BINFO_VIRTUAL_P (base_binfo))
1684 if (!BINFO_MARKED (base_binfo))
1686 BINFO_MARKED (base_binfo) = 0;
1688 /* Only walk, if it can contain more virtual bases. */
1689 if (CLASSTYPE_VBASECLASSES (BINFO_TYPE (base_binfo)))
1690 dfs_unmark_r (base_binfo);
1694 /* Like dfs_walk_all, except that binfos are not multiply walked. For
1695 non-diamond shaped hierarchies this is the same as dfs_walk_all.
1696 For diamond shaped hierarchies we must mark the virtual bases, to
1697 avoid multiple walks. */
1700 dfs_walk_once (tree binfo, tree (*pre_fn) (tree, void *),
1701 tree (*post_fn) (tree, void *), void *data)
1703 static int active = 0; /* We must not be called recursively. */
1706 gcc_assert (pre_fn || post_fn);
1707 gcc_assert (!active);
1710 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo)))
1711 /* We are not diamond shaped, and therefore cannot encounter the
1712 same binfo twice. */
1713 rval = dfs_walk_all (binfo, pre_fn, post_fn, data);
1716 rval = dfs_walk_once_r (binfo, pre_fn, post_fn, data);
1717 if (!BINFO_INHERITANCE_CHAIN (binfo))
1719 /* We are at the top of the hierarchy, and can use the
1720 CLASSTYPE_VBASECLASSES list for unmarking the virtual
1722 vec<tree, va_gc> *vbases;
1726 for (vbases = CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)), ix = 0;
1727 vec_safe_iterate (vbases, ix, &base_binfo); ix++)
1728 BINFO_MARKED (base_binfo) = 0;
1731 dfs_unmark_r (binfo);
1739 /* Worker function for dfs_walk_once_accessible. Behaves like
1740 dfs_walk_once_r, except (a) FRIENDS_P is true if special
1741 access given by the current context should be considered, (b) ONCE
1742 indicates whether bases should be marked during traversal. */
1745 dfs_walk_once_accessible_r (tree binfo, bool friends_p, bool once,
1746 tree (*pre_fn) (tree, void *),
1747 tree (*post_fn) (tree, void *), void *data)
1749 tree rval = NULL_TREE;
1753 /* Call the pre-order walking function. */
1756 rval = pre_fn (binfo, data);
1759 if (rval == dfs_skip_bases)
1766 /* Find the next child binfo to walk. */
1767 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1769 bool mark = once && BINFO_VIRTUAL_P (base_binfo);
1771 if (mark && BINFO_MARKED (base_binfo))
1774 /* If the base is inherited via private or protected
1775 inheritance, then we can't see it, unless we are a friend of
1776 the current binfo. */
1777 if (BINFO_BASE_ACCESS (binfo, ix) != access_public_node)
1782 scope = current_scope ();
1784 || TREE_CODE (scope) == NAMESPACE_DECL
1785 || !is_friend (BINFO_TYPE (binfo), scope))
1790 BINFO_MARKED (base_binfo) = 1;
1792 rval = dfs_walk_once_accessible_r (base_binfo, friends_p, once,
1793 pre_fn, post_fn, data);
1799 /* Call the post-order walking function. */
1802 rval = post_fn (binfo, data);
1803 gcc_assert (rval != dfs_skip_bases);
1810 /* Like dfs_walk_once except that only accessible bases are walked.
1811 FRIENDS_P indicates whether friendship of the local context
1812 should be considered when determining accessibility. */
1815 dfs_walk_once_accessible (tree binfo, bool friends_p,
1816 tree (*pre_fn) (tree, void *),
1817 tree (*post_fn) (tree, void *), void *data)
1819 bool diamond_shaped = CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo));
1820 tree rval = dfs_walk_once_accessible_r (binfo, friends_p, diamond_shaped,
1821 pre_fn, post_fn, data);
1825 if (!BINFO_INHERITANCE_CHAIN (binfo))
1827 /* We are at the top of the hierarchy, and can use the
1828 CLASSTYPE_VBASECLASSES list for unmarking the virtual
1830 vec<tree, va_gc> *vbases;
1834 for (vbases = CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)), ix = 0;
1835 vec_safe_iterate (vbases, ix, &base_binfo); ix++)
1836 BINFO_MARKED (base_binfo) = 0;
1839 dfs_unmark_r (binfo);
1844 /* Check that virtual overrider OVERRIDER is acceptable for base function
1845 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
1848 check_final_overrider (tree overrider, tree basefn)
1850 tree over_type = TREE_TYPE (overrider);
1851 tree base_type = TREE_TYPE (basefn);
1852 tree over_return = TREE_TYPE (over_type);
1853 tree base_return = TREE_TYPE (base_type);
1854 tree over_throw, base_throw;
1858 if (DECL_INVALID_OVERRIDER_P (overrider))
1861 if (same_type_p (base_return, over_return))
1863 else if ((CLASS_TYPE_P (over_return) && CLASS_TYPE_P (base_return))
1864 || (TREE_CODE (base_return) == TREE_CODE (over_return)
1865 && POINTER_TYPE_P (base_return)))
1867 /* Potentially covariant. */
1868 unsigned base_quals, over_quals;
1870 fail = !POINTER_TYPE_P (base_return);
1873 fail = cp_type_quals (base_return) != cp_type_quals (over_return);
1875 base_return = TREE_TYPE (base_return);
1876 over_return = TREE_TYPE (over_return);
1878 base_quals = cp_type_quals (base_return);
1879 over_quals = cp_type_quals (over_return);
1881 if ((base_quals & over_quals) != over_quals)
1884 if (CLASS_TYPE_P (base_return) && CLASS_TYPE_P (over_return))
1886 /* Strictly speaking, the standard requires the return type to be
1887 complete even if it only differs in cv-quals, but that seems
1888 like a bug in the wording. */
1889 if (!same_type_ignoring_top_level_qualifiers_p (base_return,
1892 tree binfo = lookup_base (over_return, base_return,
1893 ba_check, NULL, tf_none);
1895 if (!binfo || binfo == error_mark_node)
1900 && can_convert (TREE_TYPE (base_type), TREE_TYPE (over_type),
1901 tf_warning_or_error))
1902 /* GNU extension, allow trivial pointer conversions such as
1903 converting to void *, or qualification conversion. */
1905 /* can_convert will permit user defined conversion from a
1906 (reference to) class type. We must reject them. */
1907 over_return = non_reference (TREE_TYPE (over_type));
1908 if (CLASS_TYPE_P (over_return))
1912 warning (0, "deprecated covariant return type for %q+#D",
1914 warning (0, " overriding %q+#D", basefn);
1928 error ("invalid covariant return type for %q+#D", overrider);
1929 error (" overriding %q+#D", basefn);
1933 error ("conflicting return type specified for %q+#D", overrider);
1934 error (" overriding %q+#D", basefn);
1936 DECL_INVALID_OVERRIDER_P (overrider) = 1;
1940 /* Check throw specifier is at least as strict. */
1941 maybe_instantiate_noexcept (basefn);
1942 maybe_instantiate_noexcept (overrider);
1943 base_throw = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (basefn));
1944 over_throw = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (overrider));
1946 if (!comp_except_specs (base_throw, over_throw, ce_derived))
1948 error ("looser throw specifier for %q+#F", overrider);
1949 error (" overriding %q+#F", basefn);
1950 DECL_INVALID_OVERRIDER_P (overrider) = 1;
1954 /* Check for conflicting type attributes. */
1955 if (!comp_type_attributes (over_type, base_type))
1957 error ("conflicting type attributes specified for %q+#D", overrider);
1958 error (" overriding %q+#D", basefn);
1959 DECL_INVALID_OVERRIDER_P (overrider) = 1;
1963 if (DECL_DELETED_FN (basefn) != DECL_DELETED_FN (overrider))
1965 if (DECL_DELETED_FN (overrider))
1967 error ("deleted function %q+D", overrider);
1968 error ("overriding non-deleted function %q+D", basefn);
1969 maybe_explain_implicit_delete (overrider);
1973 error ("non-deleted function %q+D", overrider);
1974 error ("overriding deleted function %q+D", basefn);
1978 if (DECL_FINAL_P (basefn))
1980 error ("virtual function %q+D", overrider);
1981 error ("overriding final function %q+D", basefn);
1987 /* Given a class TYPE, and a function decl FNDECL, look for
1988 virtual functions in TYPE's hierarchy which FNDECL overrides.
1989 We do not look in TYPE itself, only its bases.
1991 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
1992 find that it overrides anything.
1994 We check that every function which is overridden, is correctly
1998 look_for_overrides (tree type, tree fndecl)
2000 tree binfo = TYPE_BINFO (type);
2005 /* A constructor for a class T does not override a function T
2007 if (DECL_CONSTRUCTOR_P (fndecl))
2010 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
2012 tree basetype = BINFO_TYPE (base_binfo);
2014 if (TYPE_POLYMORPHIC_P (basetype))
2015 found += look_for_overrides_r (basetype, fndecl);
2020 /* Look in TYPE for virtual functions with the same signature as
2024 look_for_overrides_here (tree type, tree fndecl)
2028 /* If there are no methods in TYPE (meaning that only implicitly
2029 declared methods will ever be provided for TYPE), then there are
2030 no virtual functions. */
2031 if (!CLASSTYPE_METHOD_VEC (type))
2034 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fndecl))
2035 ix = CLASSTYPE_DESTRUCTOR_SLOT;
2037 ix = lookup_fnfields_1 (type, DECL_NAME (fndecl));
2040 tree fns = (*CLASSTYPE_METHOD_VEC (type))[ix];
2042 for (; fns; fns = OVL_NEXT (fns))
2044 tree fn = OVL_CURRENT (fns);
2046 if (!DECL_VIRTUAL_P (fn))
2047 /* Not a virtual. */;
2048 else if (DECL_CONTEXT (fn) != type)
2049 /* Introduced with a using declaration. */;
2050 else if (DECL_STATIC_FUNCTION_P (fndecl))
2052 tree btypes = TYPE_ARG_TYPES (TREE_TYPE (fn));
2053 tree dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2054 if (compparms (TREE_CHAIN (btypes), dtypes))
2057 else if (same_signature_p (fndecl, fn))
2064 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
2065 TYPE itself and its bases. */
2068 look_for_overrides_r (tree type, tree fndecl)
2070 tree fn = look_for_overrides_here (type, fndecl);
2073 if (DECL_STATIC_FUNCTION_P (fndecl))
2075 /* A static member function cannot match an inherited
2076 virtual member function. */
2077 error ("%q+#D cannot be declared", fndecl);
2078 error (" since %q+#D declared in base class", fn);
2082 /* It's definitely virtual, even if not explicitly set. */
2083 DECL_VIRTUAL_P (fndecl) = 1;
2084 check_final_overrider (fndecl, fn);
2089 /* We failed to find one declared in this class. Look in its bases. */
2090 return look_for_overrides (type, fndecl);
2093 /* Called via dfs_walk from dfs_get_pure_virtuals. */
2096 dfs_get_pure_virtuals (tree binfo, void *data)
2098 tree type = (tree) data;
2100 /* We're not interested in primary base classes; the derived class
2101 of which they are a primary base will contain the information we
2103 if (!BINFO_PRIMARY_P (binfo))
2107 for (virtuals = BINFO_VIRTUALS (binfo);
2109 virtuals = TREE_CHAIN (virtuals))
2110 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals)))
2111 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (type), BV_FN (virtuals));
2117 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
2120 get_pure_virtuals (tree type)
2122 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
2123 is going to be overridden. */
2124 CLASSTYPE_PURE_VIRTUALS (type) = NULL;
2125 /* Now, run through all the bases which are not primary bases, and
2126 collect the pure virtual functions. We look at the vtable in
2127 each class to determine what pure virtual functions are present.
2128 (A primary base is not interesting because the derived class of
2129 which it is a primary base will contain vtable entries for the
2130 pure virtuals in the base class. */
2131 dfs_walk_once (TYPE_BINFO (type), NULL, dfs_get_pure_virtuals, type);
2134 /* Debug info for C++ classes can get very large; try to avoid
2135 emitting it everywhere.
2137 Note that this optimization wins even when the target supports
2138 BINCL (if only slightly), and reduces the amount of work for the
2142 maybe_suppress_debug_info (tree t)
2144 if (write_symbols == NO_DEBUG)
2147 /* We might have set this earlier in cp_finish_decl. */
2148 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 0;
2150 /* Always emit the information for each class every time. */
2151 if (flag_emit_class_debug_always)
2154 /* If we already know how we're handling this class, handle debug info
2156 if (CLASSTYPE_INTERFACE_KNOWN (t))
2158 if (CLASSTYPE_INTERFACE_ONLY (t))
2159 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
2160 /* else don't set it. */
2162 /* If the class has a vtable, write out the debug info along with
2164 else if (TYPE_CONTAINS_VPTR_P (t))
2165 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
2167 /* Otherwise, just emit the debug info normally. */
2170 /* Note that we want debugging information for a base class of a class
2171 whose vtable is being emitted. Normally, this would happen because
2172 calling the constructor for a derived class implies calling the
2173 constructors for all bases, which involve initializing the
2174 appropriate vptr with the vtable for the base class; but in the
2175 presence of optimization, this initialization may be optimized
2176 away, so we tell finish_vtable_vardecl that we want the debugging
2177 information anyway. */
2180 dfs_debug_mark (tree binfo, void * /*data*/)
2182 tree t = BINFO_TYPE (binfo);
2184 if (CLASSTYPE_DEBUG_REQUESTED (t))
2185 return dfs_skip_bases;
2187 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
2192 /* Write out the debugging information for TYPE, whose vtable is being
2193 emitted. Also walk through our bases and note that we want to
2194 write out information for them. This avoids the problem of not
2195 writing any debug info for intermediate basetypes whose
2196 constructors, and thus the references to their vtables, and thus
2197 the vtables themselves, were optimized away. */
2200 note_debug_info_needed (tree type)
2202 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
2204 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)) = 0;
2205 rest_of_type_compilation (type, toplevel_bindings_p ());
2208 dfs_walk_all (TYPE_BINFO (type), dfs_debug_mark, NULL, 0);
2212 print_search_statistics (void)
2214 if (! GATHER_STATISTICS)
2216 fprintf (stderr, "no search statistics\n");
2220 fprintf (stderr, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
2221 n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1);
2222 fprintf (stderr, "%d fnfields searched in %d calls to lookup_fnfields\n",
2223 n_outer_fields_searched, n_calls_lookup_fnfields);
2224 fprintf (stderr, "%d calls to get_base_type\n", n_calls_get_base_type);
2228 reinit_search_statistics (void)
2230 n_fields_searched = 0;
2231 n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0;
2232 n_calls_lookup_fnfields = 0, n_calls_lookup_fnfields_1 = 0;
2233 n_calls_get_base_type = 0;
2234 n_outer_fields_searched = 0;
2235 n_contexts_saved = 0;
2238 /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2239 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2240 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2241 bases have been encountered already in the tree walk. PARENT_CONVS
2242 is the list of lists of conversion functions that could hide CONV
2243 and OTHER_CONVS is the list of lists of conversion functions that
2244 could hide or be hidden by CONV, should virtualness be involved in
2245 the hierarchy. Merely checking the conversion op's name is not
2246 enough because two conversion operators to the same type can have
2247 different names. Return nonzero if we are visible. */
2250 check_hidden_convs (tree binfo, int virtual_depth, int virtualness,
2251 tree to_type, tree parent_convs, tree other_convs)
2255 /* See if we are hidden by a parent conversion. */
2256 for (level = parent_convs; level; level = TREE_CHAIN (level))
2257 for (probe = TREE_VALUE (level); probe; probe = TREE_CHAIN (probe))
2258 if (same_type_p (to_type, TREE_TYPE (probe)))
2261 if (virtual_depth || virtualness)
2263 /* In a virtual hierarchy, we could be hidden, or could hide a
2264 conversion function on the other_convs list. */
2265 for (level = other_convs; level; level = TREE_CHAIN (level))
2271 if (!(virtual_depth || TREE_STATIC (level)))
2272 /* Neither is morally virtual, so cannot hide each other. */
2275 if (!TREE_VALUE (level))
2276 /* They evaporated away already. */
2279 they_hide_us = (virtual_depth
2280 && original_binfo (binfo, TREE_PURPOSE (level)));
2281 we_hide_them = (!they_hide_us && TREE_STATIC (level)
2282 && original_binfo (TREE_PURPOSE (level), binfo));
2284 if (!(we_hide_them || they_hide_us))
2285 /* Neither is within the other, so no hiding can occur. */
2288 for (prev = &TREE_VALUE (level), other = *prev; other;)
2290 if (same_type_p (to_type, TREE_TYPE (other)))
2293 /* We are hidden. */
2298 /* We hide the other one. */
2299 other = TREE_CHAIN (other);
2304 prev = &TREE_CHAIN (other);
2312 /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2313 of conversion functions, the first slot will be for the current
2314 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2315 of conversion functions from children of the current binfo,
2316 concatenated with conversions from elsewhere in the hierarchy --
2317 that list begins with OTHER_CONVS. Return a single list of lists
2318 containing only conversions from the current binfo and its
2322 split_conversions (tree my_convs, tree parent_convs,
2323 tree child_convs, tree other_convs)
2328 /* Remove the original other_convs portion from child_convs. */
2329 for (prev = NULL, t = child_convs;
2330 t != other_convs; prev = t, t = TREE_CHAIN (t))
2334 TREE_CHAIN (prev) = NULL_TREE;
2336 child_convs = NULL_TREE;
2338 /* Attach the child convs to any we had at this level. */
2341 my_convs = parent_convs;
2342 TREE_CHAIN (my_convs) = child_convs;
2345 my_convs = child_convs;
2350 /* Worker for lookup_conversions. Lookup conversion functions in
2351 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in
2352 a morally virtual base, and VIRTUALNESS is nonzero, if we've
2353 encountered virtual bases already in the tree walk. PARENT_CONVS &
2354 PARENT_TPL_CONVS are lists of list of conversions within parent
2355 binfos. OTHER_CONVS and OTHER_TPL_CONVS are conversions found
2356 elsewhere in the tree. Return the conversions found within this
2357 portion of the graph in CONVS and TPL_CONVS. Return nonzero is we
2358 encountered virtualness. We keep template and non-template
2359 conversions separate, to avoid unnecessary type comparisons.
2361 The located conversion functions are held in lists of lists. The
2362 TREE_VALUE of the outer list is the list of conversion functions
2363 found in a particular binfo. The TREE_PURPOSE of both the outer
2364 and inner lists is the binfo at which those conversions were
2365 found. TREE_STATIC is set for those lists within of morally
2366 virtual binfos. The TREE_VALUE of the inner list is the conversion
2367 function or overload itself. The TREE_TYPE of each inner list node
2368 is the converted-to type. */
2371 lookup_conversions_r (tree binfo,
2372 int virtual_depth, int virtualness,
2373 tree parent_convs, tree parent_tpl_convs,
2374 tree other_convs, tree other_tpl_convs,
2375 tree *convs, tree *tpl_convs)
2377 int my_virtualness = 0;
2378 tree my_convs = NULL_TREE;
2379 tree my_tpl_convs = NULL_TREE;
2380 tree child_convs = NULL_TREE;
2381 tree child_tpl_convs = NULL_TREE;
2384 vec<tree, va_gc> *method_vec = CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo));
2387 /* If we have no conversion operators, then don't look. */
2388 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo)))
2390 *convs = *tpl_convs = NULL_TREE;
2395 if (BINFO_VIRTUAL_P (binfo))
2398 /* First, locate the unhidden ones at this level. */
2399 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
2400 vec_safe_iterate (method_vec, i, &conv);
2403 tree cur = OVL_CURRENT (conv);
2405 if (!DECL_CONV_FN_P (cur))
2408 if (TREE_CODE (cur) == TEMPLATE_DECL)
2410 /* Only template conversions can be overloaded, and we must
2411 flatten them out and check each one individually. */
2414 for (tpls = conv; tpls; tpls = OVL_NEXT (tpls))
2416 tree tpl = OVL_CURRENT (tpls);
2417 tree type = DECL_CONV_FN_TYPE (tpl);
2419 if (check_hidden_convs (binfo, virtual_depth, virtualness,
2420 type, parent_tpl_convs, other_tpl_convs))
2422 my_tpl_convs = tree_cons (binfo, tpl, my_tpl_convs);
2423 TREE_TYPE (my_tpl_convs) = type;
2426 TREE_STATIC (my_tpl_convs) = 1;
2434 tree name = DECL_NAME (cur);
2436 if (!IDENTIFIER_MARKED (name))
2438 tree type = DECL_CONV_FN_TYPE (cur);
2439 if (type_uses_auto (type))
2442 type = DECL_CONV_FN_TYPE (cur);
2445 if (check_hidden_convs (binfo, virtual_depth, virtualness,
2446 type, parent_convs, other_convs))
2448 my_convs = tree_cons (binfo, conv, my_convs);
2449 TREE_TYPE (my_convs) = type;
2452 TREE_STATIC (my_convs) = 1;
2455 IDENTIFIER_MARKED (name) = 1;
2463 parent_convs = tree_cons (binfo, my_convs, parent_convs);
2465 TREE_STATIC (parent_convs) = 1;
2470 parent_tpl_convs = tree_cons (binfo, my_tpl_convs, parent_tpl_convs);
2472 TREE_STATIC (parent_tpl_convs) = 1;
2475 child_convs = other_convs;
2476 child_tpl_convs = other_tpl_convs;
2478 /* Now iterate over each base, looking for more conversions. */
2479 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2481 tree base_convs, base_tpl_convs;
2482 unsigned base_virtualness;
2484 base_virtualness = lookup_conversions_r (base_binfo,
2485 virtual_depth, virtualness,
2486 parent_convs, parent_tpl_convs,
2487 child_convs, child_tpl_convs,
2488 &base_convs, &base_tpl_convs);
2489 if (base_virtualness)
2490 my_virtualness = virtualness = 1;
2491 child_convs = chainon (base_convs, child_convs);
2492 child_tpl_convs = chainon (base_tpl_convs, child_tpl_convs);
2495 /* Unmark the conversions found at this level */
2496 for (conv = my_convs; conv; conv = TREE_CHAIN (conv))
2497 IDENTIFIER_MARKED (DECL_NAME (OVL_CURRENT (TREE_VALUE (conv)))) = 0;
2499 *convs = split_conversions (my_convs, parent_convs,
2500 child_convs, other_convs);
2501 *tpl_convs = split_conversions (my_tpl_convs, parent_tpl_convs,
2502 child_tpl_convs, other_tpl_convs);
2504 return my_virtualness;
2507 /* Return a TREE_LIST containing all the non-hidden user-defined
2508 conversion functions for TYPE (and its base-classes). The
2509 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2510 function. The TREE_PURPOSE is the BINFO from which the conversion
2511 functions in this node were selected. This function is effectively
2512 performing a set of member lookups as lookup_fnfield does, but
2513 using the type being converted to as the unique key, rather than the
2517 lookup_conversions (tree type)
2519 tree convs, tpl_convs;
2520 tree list = NULL_TREE;
2522 complete_type (type);
2523 if (!TYPE_BINFO (type))
2526 lookup_conversions_r (TYPE_BINFO (type), 0, 0,
2527 NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
2528 &convs, &tpl_convs);
2530 /* Flatten the list-of-lists */
2531 for (; convs; convs = TREE_CHAIN (convs))
2535 for (probe = TREE_VALUE (convs); probe; probe = next)
2537 next = TREE_CHAIN (probe);
2539 TREE_CHAIN (probe) = list;
2544 for (; tpl_convs; tpl_convs = TREE_CHAIN (tpl_convs))
2548 for (probe = TREE_VALUE (tpl_convs); probe; probe = next)
2550 next = TREE_CHAIN (probe);
2552 TREE_CHAIN (probe) = list;
2560 /* Returns the binfo of the first direct or indirect virtual base derived
2561 from BINFO, or NULL if binfo is not via virtual. */
2564 binfo_from_vbase (tree binfo)
2566 for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
2568 if (BINFO_VIRTUAL_P (binfo))
2574 /* Returns the binfo of the first direct or indirect virtual base derived
2575 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2579 binfo_via_virtual (tree binfo, tree limit)
2581 if (limit && !CLASSTYPE_VBASECLASSES (limit))
2582 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2585 for (; binfo && !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), limit);
2586 binfo = BINFO_INHERITANCE_CHAIN (binfo))
2588 if (BINFO_VIRTUAL_P (binfo))
2594 /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2595 Find the equivalent binfo within whatever graph HERE is located.
2596 This is the inverse of original_binfo. */
2599 copied_binfo (tree binfo, tree here)
2601 tree result = NULL_TREE;
2603 if (BINFO_VIRTUAL_P (binfo))
2607 for (t = here; BINFO_INHERITANCE_CHAIN (t);
2608 t = BINFO_INHERITANCE_CHAIN (t))
2611 result = binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (t));
2613 else if (BINFO_INHERITANCE_CHAIN (binfo))
2619 cbinfo = copied_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
2620 for (ix = 0; BINFO_BASE_ITERATE (cbinfo, ix, base_binfo); ix++)
2621 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), BINFO_TYPE (binfo)))
2623 result = base_binfo;
2629 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here), BINFO_TYPE (binfo)));
2633 gcc_assert (result);
2638 binfo_for_vbase (tree base, tree t)
2642 vec<tree, va_gc> *vbases;
2644 for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
2645 vec_safe_iterate (vbases, ix, &binfo); ix++)
2646 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), base))
2651 /* BINFO is some base binfo of HERE, within some other
2652 hierarchy. Return the equivalent binfo, but in the hierarchy
2653 dominated by HERE. This is the inverse of copied_binfo. If BINFO
2654 is not a base binfo of HERE, returns NULL_TREE. */
2657 original_binfo (tree binfo, tree here)
2661 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (here)))
2663 else if (BINFO_VIRTUAL_P (binfo))
2664 result = (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here))
2665 ? binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (here))
2667 else if (BINFO_INHERITANCE_CHAIN (binfo))
2671 base_binfos = original_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
2677 for (ix = 0; (base_binfo = BINFO_BASE_BINFO (base_binfos, ix)); ix++)
2678 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
2679 BINFO_TYPE (binfo)))
2681 result = base_binfo;