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 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* High-level class interface. */
36 #define obstack_chunk_alloc xmalloc
37 #define obstack_chunk_free free
41 /* Obstack used for remembering decision points of breadth-first. */
43 static struct obstack search_obstack;
45 /* Methods for pushing and popping objects to and from obstacks. */
48 push_stack_level (obstack, tp, size)
49 struct obstack *obstack;
50 char *tp; /* Sony NewsOS 5.0 compiler doesn't like void * here. */
53 struct stack_level *stack;
54 obstack_grow (obstack, tp, size);
55 stack = (struct stack_level *) ((char*)obstack_next_free (obstack) - size);
56 obstack_finish (obstack);
57 stack->obstack = obstack;
58 stack->first = (tree *) obstack_base (obstack);
59 stack->limit = obstack_room (obstack) / sizeof (tree *);
64 pop_stack_level (stack)
65 struct stack_level *stack;
67 struct stack_level *tem = stack;
68 struct obstack *obstack = tem->obstack;
70 obstack_free (obstack, tem);
74 #define search_level stack_level
75 static struct search_level *search_stack;
79 /* The class dominating the hierarchy. */
81 /* A pointer to a complete object of the indicated TYPE. */
86 static tree lookup_field_1 PARAMS ((tree, tree));
87 static int is_subobject_of_p PARAMS ((tree, tree, tree));
88 static tree dfs_check_overlap PARAMS ((tree, void *));
89 static tree dfs_no_overlap_yet PARAMS ((tree, void *));
90 static base_kind lookup_base_r
91 PARAMS ((tree, tree, base_access, int, int, int, tree *));
92 static int dynamic_cast_base_recurse PARAMS ((tree, tree, int, tree *));
93 static tree marked_pushdecls_p PARAMS ((tree, void *));
94 static tree unmarked_pushdecls_p PARAMS ((tree, void *));
95 static tree dfs_debug_unmarkedp PARAMS ((tree, void *));
96 static tree dfs_debug_mark PARAMS ((tree, void *));
97 static tree dfs_get_vbase_types PARAMS ((tree, void *));
98 static tree dfs_push_type_decls PARAMS ((tree, void *));
99 static tree dfs_push_decls PARAMS ((tree, void *));
100 static tree dfs_unuse_fields PARAMS ((tree, void *));
101 static tree add_conversions PARAMS ((tree, void *));
102 static int covariant_return_p PARAMS ((tree, tree));
103 static int check_final_overrider PARAMS ((tree, tree));
104 static int look_for_overrides_r PARAMS ((tree, tree));
105 static struct search_level *push_search_level
106 PARAMS ((struct stack_level *, struct obstack *));
107 static struct search_level *pop_search_level
108 PARAMS ((struct stack_level *));
110 PARAMS ((tree, tree (*) (tree, void *), tree (*) (tree, void *),
112 static tree lookup_field_queue_p PARAMS ((tree, void *));
113 static int shared_member_p PARAMS ((tree));
114 static tree lookup_field_r PARAMS ((tree, void *));
115 static tree canonical_binfo PARAMS ((tree));
116 static tree shared_marked_p PARAMS ((tree, void *));
117 static tree shared_unmarked_p PARAMS ((tree, void *));
118 static int dependent_base_p PARAMS ((tree));
119 static tree dfs_accessible_queue_p PARAMS ((tree, void *));
120 static tree dfs_accessible_p PARAMS ((tree, void *));
121 static tree dfs_access_in_type PARAMS ((tree, void *));
122 static access_kind access_in_type PARAMS ((tree, tree));
123 static tree dfs_canonical_queue PARAMS ((tree, void *));
124 static tree dfs_assert_unmarked_p PARAMS ((tree, void *));
125 static void assert_canonical_unmarked PARAMS ((tree));
126 static int protected_accessible_p PARAMS ((tree, tree, tree));
127 static int friend_accessible_p PARAMS ((tree, tree, tree));
128 static void setup_class_bindings PARAMS ((tree, int));
129 static int template_self_reference_p PARAMS ((tree, tree));
130 static tree dfs_find_vbase_instance PARAMS ((tree, void *));
131 static tree dfs_get_pure_virtuals PARAMS ((tree, void *));
132 static tree dfs_build_inheritance_graph_order PARAMS ((tree, void *));
134 /* Allocate a level of searching. */
136 static struct search_level *
137 push_search_level (stack, obstack)
138 struct stack_level *stack;
139 struct obstack *obstack;
141 struct search_level tem;
144 return push_stack_level (obstack, (char *)&tem, sizeof (tem));
147 /* Discard a level of search allocation. */
149 static struct search_level *
150 pop_search_level (obstack)
151 struct stack_level *obstack;
153 register struct search_level *stack = pop_stack_level (obstack);
158 /* Variables for gathering statistics. */
159 #ifdef GATHER_STATISTICS
160 static int n_fields_searched;
161 static int n_calls_lookup_field, n_calls_lookup_field_1;
162 static int n_calls_lookup_fnfields, n_calls_lookup_fnfields_1;
163 static int n_calls_get_base_type;
164 static int n_outer_fields_searched;
165 static int n_contexts_saved;
166 #endif /* GATHER_STATISTICS */
169 /* Worker for lookup_base. BINFO is the binfo we are searching at,
170 BASE is the RECORD_TYPE we are searching for. ACCESS is the
171 required access checks. WITHIN_CURRENT_SCOPE, IS_NON_PUBLIC and
172 IS_VIRTUAL indicate how BINFO was reached from the start of the
173 search. WITHIN_CURRENT_SCOPE is true if we met the current scope,
174 or friend thereof (this allows us to determine whether a protected
175 base is accessible or not). IS_NON_PUBLIC indicates whether BINFO
176 is accessible and IS_VIRTUAL indicates if it is morally virtual.
178 If BINFO is of the required type, then *BINFO_PTR is examined to
179 compare with any other instance of BASE we might have already
180 discovered. *BINFO_PTR is initialized and a base_kind return value
181 indicates what kind of base was located.
183 Otherwise BINFO's bases are searched. */
186 lookup_base_r (binfo, base, access, within_current_scope,
187 is_non_public, is_virtual, binfo_ptr)
190 int within_current_scope;
191 int is_non_public; /* inside a non-public part */
192 int is_virtual; /* inside a virtual part */
197 base_kind found = bk_not_base;
199 if (access == ba_check
200 && !within_current_scope
201 && is_friend (BINFO_TYPE (binfo), current_scope ()))
203 /* Do not clear is_non_public here. If A is a private base of B, A
204 is not allowed to convert a B* to an A*. */
205 within_current_scope = 1;
208 if (same_type_p (BINFO_TYPE (binfo), base))
210 /* We have found a base. Check against what we have found
212 found = bk_same_type;
214 found = bk_via_virtual;
216 found = bk_inaccessible;
220 else if (!is_virtual || !tree_int_cst_equal (BINFO_OFFSET (binfo),
221 BINFO_OFFSET (*binfo_ptr)))
223 if (access != ba_any)
225 else if (!is_virtual)
226 /* Prefer a non-virtual base. */
234 bases = BINFO_BASETYPES (binfo);
238 for (i = TREE_VEC_LENGTH (bases); i--;)
240 tree base_binfo = TREE_VEC_ELT (bases, i);
241 int this_non_public = is_non_public;
242 int this_virtual = is_virtual;
245 if (access <= ba_ignore)
247 else if (TREE_VIA_PUBLIC (base_binfo))
249 else if (access == ba_not_special)
251 else if (TREE_VIA_PROTECTED (base_binfo) && within_current_scope)
253 else if (is_friend (BINFO_TYPE (binfo), current_scope ()))
258 if (TREE_VIA_VIRTUAL (base_binfo))
261 bk = lookup_base_r (base_binfo, base,
262 access, within_current_scope,
263 this_non_public, this_virtual,
269 if (access != ba_any)
274 case bk_inaccessible:
275 if (found == bk_not_base)
277 my_friendly_assert (found == bk_via_virtual
278 || found == bk_inaccessible, 20010723);
286 my_friendly_assert (found == bk_not_base, 20010723);
291 if (found != bk_ambig)
302 /* Lookup BASE in the hierarchy dominated by T. Do access checking as
303 ACCESS specifies. Return the binfo we discover (which might not be
304 canonical). If KIND_PTR is non-NULL, fill with information about
305 what kind of base we discovered.
307 If ba_quiet bit is set in ACCESS, then do not issue an error, and
308 return NULL_TREE for failure. */
311 lookup_base (t, base, access, kind_ptr)
316 tree binfo = NULL; /* The binfo we've found so far. */
319 if (t == error_mark_node || base == error_mark_node)
322 *kind_ptr = bk_not_base;
323 return error_mark_node;
325 my_friendly_assert (TYPE_P (t) && TYPE_P (base), 20011127);
327 /* Ensure that the types are instantiated. */
328 t = complete_type (TYPE_MAIN_VARIANT (t));
329 base = complete_type (TYPE_MAIN_VARIANT (base));
331 bk = lookup_base_r (TYPE_BINFO (t), base, access & ~ba_quiet,
336 case bk_inaccessible:
338 if (!(access & ba_quiet))
340 error ("`%T' is an inaccessible base of `%T'", base, t);
341 binfo = error_mark_node;
345 if (access != ba_any)
348 if (!(access & ba_quiet))
350 error ("`%T' is an ambiguous base of `%T'", base, t);
351 binfo = error_mark_node;
364 /* Worker function for get_dynamic_cast_base_type. */
367 dynamic_cast_base_recurse (subtype, binfo, via_virtual, offset_ptr)
377 if (BINFO_TYPE (binfo) == subtype)
383 *offset_ptr = BINFO_OFFSET (binfo);
388 binfos = BINFO_BASETYPES (binfo);
389 n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
390 for (i = 0; i < n_baselinks; i++)
392 tree base_binfo = TREE_VEC_ELT (binfos, i);
395 if (!TREE_VIA_PUBLIC (base_binfo))
397 rval = dynamic_cast_base_recurse
398 (subtype, base_binfo,
399 via_virtual || TREE_VIA_VIRTUAL (base_binfo), offset_ptr);
403 worst = worst >= 0 ? -3 : worst;
406 else if (rval == -3 && worst != -1)
412 /* The dynamic cast runtime needs a hint about how the static SUBTYPE type
413 started from is related to the required TARGET type, in order to optimize
414 the inheritance graph search. This information is independent of the
415 current context, and ignores private paths, hence get_base_distance is
416 inappropriate. Return a TREE specifying the base offset, BOFF.
417 BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
418 and there are no public virtual SUBTYPE bases.
419 BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
420 BOFF == -2, SUBTYPE is not a public base.
421 BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
424 get_dynamic_cast_base_type (subtype, target)
428 tree offset = NULL_TREE;
429 int boff = dynamic_cast_base_recurse (subtype, TYPE_BINFO (target),
434 offset = build_int_2 (boff, -1);
435 TREE_TYPE (offset) = ssizetype;
439 /* Search for a member with name NAME in a multiple inheritance lattice
440 specified by TYPE. If it does not exist, return NULL_TREE.
441 If the member is ambiguously referenced, return `error_mark_node'.
442 Otherwise, return the FIELD_DECL. */
444 /* Do a 1-level search for NAME as a member of TYPE. The caller must
445 figure out whether it can access this field. (Since it is only one
446 level, this is reasonable.) */
449 lookup_field_1 (type, name)
454 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
455 || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
456 || TREE_CODE (type) == TYPENAME_TYPE)
457 /* The TYPE_FIELDS of a TEMPLATE_TYPE_PARM and
458 BOUND_TEMPLATE_TEMPLATE_PARM are not fields at all;
459 instead TYPE_FIELDS is the TEMPLATE_PARM_INDEX. (Miraculously,
460 the code often worked even when we treated the index as a list
462 The TYPE_FIELDS of TYPENAME_TYPE is its TYPENAME_TYPE_FULLNAME. */
466 && DECL_LANG_SPECIFIC (TYPE_NAME (type))
467 && DECL_SORTED_FIELDS (TYPE_NAME (type)))
469 tree *fields = &TREE_VEC_ELT (DECL_SORTED_FIELDS (TYPE_NAME (type)), 0);
470 int lo = 0, hi = TREE_VEC_LENGTH (DECL_SORTED_FIELDS (TYPE_NAME (type)));
477 #ifdef GATHER_STATISTICS
479 #endif /* GATHER_STATISTICS */
481 if (DECL_NAME (fields[i]) > name)
483 else if (DECL_NAME (fields[i]) < name)
487 /* We might have a nested class and a field with the
488 same name; we sorted them appropriately via
489 field_decl_cmp, so just look for the last field with
492 && DECL_NAME (fields[i+1]) == name)
500 field = TYPE_FIELDS (type);
502 #ifdef GATHER_STATISTICS
503 n_calls_lookup_field_1++;
504 #endif /* GATHER_STATISTICS */
507 #ifdef GATHER_STATISTICS
509 #endif /* GATHER_STATISTICS */
510 my_friendly_assert (DECL_P (field), 0);
511 if (DECL_NAME (field) == NULL_TREE
512 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
514 tree temp = lookup_field_1 (TREE_TYPE (field), name);
518 if (TREE_CODE (field) == USING_DECL)
519 /* For now, we're just treating member using declarations as
520 old ARM-style access declarations. Thus, there's no reason
521 to return a USING_DECL, and the rest of the compiler can't
522 handle it. Once the class is defined, these are purged
523 from TYPE_FIELDS anyhow; see handle_using_decl. */
525 else if (DECL_NAME (field) == name)
527 field = TREE_CHAIN (field);
530 if (name == vptr_identifier)
532 /* Give the user what s/he thinks s/he wants. */
533 if (TYPE_POLYMORPHIC_P (type))
534 return TYPE_VFIELD (type);
539 /* There are a number of cases we need to be aware of here:
540 current_class_type current_function_decl
547 Those last two make life interesting. If we're in a function which is
548 itself inside a class, we need decls to go into the fn's decls (our
549 second case below). But if we're in a class and the class itself is
550 inside a function, we need decls to go into the decls for the class. To
551 achieve this last goal, we must see if, when both current_class_ptr and
552 current_function_decl are set, the class was declared inside that
553 function. If so, we know to put the decls into the class's scope. */
558 if (current_function_decl == NULL_TREE)
559 return current_class_type;
560 if (current_class_type == NULL_TREE)
561 return current_function_decl;
562 if ((DECL_FUNCTION_MEMBER_P (current_function_decl)
563 && same_type_p (DECL_CONTEXT (current_function_decl),
565 || (DECL_FRIEND_CONTEXT (current_function_decl)
566 && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl),
567 current_class_type)))
568 return current_function_decl;
570 return current_class_type;
573 /* Returns non-zero if we are currently in a function scope. Note
574 that this function returns zero if we are within a local class, but
575 not within a member function body of the local class. */
578 at_function_scope_p ()
580 tree cs = current_scope ();
581 return cs && TREE_CODE (cs) == FUNCTION_DECL;
584 /* Return the scope of DECL, as appropriate when doing name-lookup. */
587 context_for_name_lookup (decl)
592 For the purposes of name lookup, after the anonymous union
593 definition, the members of the anonymous union are considered to
594 have been defined in the scope in which the anonymous union is
596 tree context = DECL_CONTEXT (decl);
598 while (context && TYPE_P (context) && ANON_AGGR_TYPE_P (context))
599 context = TYPE_CONTEXT (context);
601 context = global_namespace;
606 /* Return a canonical BINFO if BINFO is a virtual base, or just BINFO
610 canonical_binfo (binfo)
613 return (TREE_VIA_VIRTUAL (binfo)
614 ? TYPE_BINFO (BINFO_TYPE (binfo)) : binfo);
617 /* A queue function that simply ensures that we walk into the
618 canonical versions of virtual bases. */
621 dfs_canonical_queue (binfo, data)
623 void *data ATTRIBUTE_UNUSED;
625 return canonical_binfo (binfo);
628 /* Called via dfs_walk from assert_canonical_unmarked. */
631 dfs_assert_unmarked_p (binfo, data)
633 void *data ATTRIBUTE_UNUSED;
635 my_friendly_assert (!BINFO_MARKED (binfo), 0);
639 /* Asserts that all the nodes below BINFO (using the canonical
640 versions of virtual bases) are unmarked. */
643 assert_canonical_unmarked (binfo)
646 dfs_walk (binfo, dfs_assert_unmarked_p, dfs_canonical_queue, 0);
649 /* If BINFO is marked, return a canonical version of BINFO.
650 Otherwise, return NULL_TREE. */
653 shared_marked_p (binfo, data)
657 binfo = canonical_binfo (binfo);
658 return markedp (binfo, data);
661 /* If BINFO is not marked, return a canonical version of BINFO.
662 Otherwise, return NULL_TREE. */
665 shared_unmarked_p (binfo, data)
669 binfo = canonical_binfo (binfo);
670 return unmarkedp (binfo, data);
673 /* The accessibility routines use BINFO_ACCESS for scratch space
674 during the computation of the accssibility of some declaration. */
676 #define BINFO_ACCESS(NODE) \
677 ((access_kind) ((TREE_LANG_FLAG_1 (NODE) << 1) | TREE_LANG_FLAG_6 (NODE)))
679 /* Set the access associated with NODE to ACCESS. */
681 #define SET_BINFO_ACCESS(NODE, ACCESS) \
682 ((TREE_LANG_FLAG_1 (NODE) = ((ACCESS) & 2) != 0), \
683 (TREE_LANG_FLAG_6 (NODE) = ((ACCESS) & 1) != 0))
685 /* Called from access_in_type via dfs_walk. Calculate the access to
686 DATA (which is really a DECL) in BINFO. */
689 dfs_access_in_type (binfo, data)
693 tree decl = (tree) data;
694 tree type = BINFO_TYPE (binfo);
695 access_kind access = ak_none;
697 if (context_for_name_lookup (decl) == type)
699 /* If we have desceneded to the scope of DECL, just note the
700 appropriate access. */
701 if (TREE_PRIVATE (decl))
703 else if (TREE_PROTECTED (decl))
704 access = ak_protected;
710 /* First, check for an access-declaration that gives us more
711 access to the DECL. The CONST_DECL for an enumeration
712 constant will not have DECL_LANG_SPECIFIC, and thus no
714 if (DECL_LANG_SPECIFIC (decl) && !DECL_DISCRIMINATOR_P (decl))
716 tree decl_access = purpose_member (type, DECL_ACCESS (decl));
718 access = ((access_kind)
719 TREE_INT_CST_LOW (TREE_VALUE (decl_access)));
728 /* Otherwise, scan our baseclasses, and pick the most favorable
730 binfos = BINFO_BASETYPES (binfo);
731 n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
732 for (i = 0; i < n_baselinks; ++i)
734 tree base_binfo = TREE_VEC_ELT (binfos, i);
735 access_kind base_access
736 = BINFO_ACCESS (canonical_binfo (base_binfo));
738 if (base_access == ak_none || base_access == ak_private)
739 /* If it was not accessible in the base, or only
740 accessible as a private member, we can't access it
742 base_access = ak_none;
743 else if (TREE_VIA_PROTECTED (base_binfo))
744 /* Public and protected members in the base are
746 base_access = ak_protected;
747 else if (!TREE_VIA_PUBLIC (base_binfo))
748 /* Public and protected members in the base are
750 base_access = ak_private;
752 /* See if the new access, via this base, gives more
753 access than our previous best access. */
754 if (base_access != ak_none
755 && (base_access == ak_public
756 || (base_access == ak_protected
757 && access != ak_public)
758 || (base_access == ak_private
759 && access == ak_none)))
761 access = base_access;
763 /* If the new access is public, we can't do better. */
764 if (access == ak_public)
771 /* Note the access to DECL in TYPE. */
772 SET_BINFO_ACCESS (binfo, access);
774 /* Mark TYPE as visited so that if we reach it again we do not
775 duplicate our efforts here. */
776 SET_BINFO_MARKED (binfo);
781 /* Return the access to DECL in TYPE. */
784 access_in_type (type, decl)
788 tree binfo = TYPE_BINFO (type);
790 /* We must take into account
794 If a name can be reached by several paths through a multiple
795 inheritance graph, the access is that of the path that gives
798 The algorithm we use is to make a post-order depth-first traversal
799 of the base-class hierarchy. As we come up the tree, we annotate
800 each node with the most lenient access. */
801 dfs_walk_real (binfo, 0, dfs_access_in_type, shared_unmarked_p, decl);
802 dfs_walk (binfo, dfs_unmark, shared_marked_p, 0);
803 assert_canonical_unmarked (binfo);
805 return BINFO_ACCESS (binfo);
808 /* Called from dfs_accessible_p via dfs_walk. */
811 dfs_accessible_queue_p (binfo, data)
813 void *data ATTRIBUTE_UNUSED;
815 if (BINFO_MARKED (binfo))
818 /* If this class is inherited via private or protected inheritance,
819 then we can't see it, unless we are a friend of the subclass. */
820 if (!TREE_VIA_PUBLIC (binfo)
821 && !is_friend (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
825 return canonical_binfo (binfo);
828 /* Called from dfs_accessible_p via dfs_walk. */
831 dfs_accessible_p (binfo, data)
835 int protected_ok = data != 0;
838 SET_BINFO_MARKED (binfo);
839 access = BINFO_ACCESS (binfo);
840 if (access == ak_public || (access == ak_protected && protected_ok))
842 else if (access != ak_none
843 && is_friend (BINFO_TYPE (binfo), current_scope ()))
849 /* Returns non-zero if it is OK to access DECL through an object
850 indiated by BINFO in the context of DERIVED. */
853 protected_accessible_p (decl, derived, binfo)
860 /* We're checking this clause from [class.access.base]
862 m as a member of N is protected, and the reference occurs in a
863 member or friend of class N, or in a member or friend of a
864 class P derived from N, where m as a member of P is private or
867 Here DERIVED is a possible P and DECL is m. accessible_p will
868 iterate over various values of N, but the access to m in DERIVED
871 Note that I believe that the passage above is wrong, and should read
872 "...is private or protected or public"; otherwise you get bizarre results
873 whereby a public using-decl can prevent you from accessing a protected
874 member of a base. (jason 2000/02/28) */
876 /* If DERIVED isn't derived from m's class, then it can't be a P. */
877 if (!DERIVED_FROM_P (context_for_name_lookup (decl), derived))
880 access = access_in_type (derived, decl);
882 /* If m is inaccessible in DERIVED, then it's not a P. */
883 if (access == ak_none)
888 When a friend or a member function of a derived class references
889 a protected nonstatic member of a base class, an access check
890 applies in addition to those described earlier in clause
891 _class.access_) Except when forming a pointer to member
892 (_expr.unary.op_), the access must be through a pointer to,
893 reference to, or object of the derived class itself (or any class
894 derived from that class) (_expr.ref_). If the access is to form
895 a pointer to member, the nested-name-specifier shall name the
896 derived class (or any class derived from that class). */
897 if (DECL_NONSTATIC_MEMBER_P (decl))
899 /* We can tell through what the reference is occurring by
900 chasing BINFO up to the root. */
902 while (BINFO_INHERITANCE_CHAIN (t))
903 t = BINFO_INHERITANCE_CHAIN (t);
905 if (!DERIVED_FROM_P (derived, BINFO_TYPE (t)))
912 /* Returns non-zero if SCOPE is a friend of a type which would be able
913 to access DECL through the object indicated by BINFO. */
916 friend_accessible_p (scope, decl, binfo)
921 tree befriending_classes;
927 if (TREE_CODE (scope) == FUNCTION_DECL
928 || DECL_FUNCTION_TEMPLATE_P (scope))
929 befriending_classes = DECL_BEFRIENDING_CLASSES (scope);
930 else if (TYPE_P (scope))
931 befriending_classes = CLASSTYPE_BEFRIENDING_CLASSES (scope);
935 for (t = befriending_classes; t; t = TREE_CHAIN (t))
936 if (protected_accessible_p (decl, TREE_VALUE (t), binfo))
939 /* Nested classes are implicitly friends of their enclosing types, as
940 per core issue 45 (this is a change from the standard). */
942 for (t = TYPE_CONTEXT (scope); t && TYPE_P (t); t = TYPE_CONTEXT (t))
943 if (protected_accessible_p (decl, t, binfo))
946 if (TREE_CODE (scope) == FUNCTION_DECL
947 || DECL_FUNCTION_TEMPLATE_P (scope))
949 /* Perhaps this SCOPE is a member of a class which is a
951 if (DECL_CLASS_SCOPE_P (decl)
952 && friend_accessible_p (DECL_CONTEXT (scope), decl, binfo))
955 /* Or an instantiation of something which is a friend. */
956 if (DECL_TEMPLATE_INFO (scope))
957 return friend_accessible_p (DECL_TI_TEMPLATE (scope), decl, binfo);
959 else if (CLASSTYPE_TEMPLATE_INFO (scope))
960 return friend_accessible_p (CLASSTYPE_TI_TEMPLATE (scope), decl, binfo);
965 /* Perform access control on TYPE_DECL VAL, which was looked up in TYPE.
966 This is fairly complex, so here's the design:
968 The lang_extdef nonterminal sets type_lookups to NULL_TREE before we
969 start to process a top-level declaration.
970 As we process the decl-specifier-seq for the declaration, any types we
971 see that might need access control are passed to type_access_control,
972 which defers checking by adding them to type_lookups.
973 When we are done with the decl-specifier-seq, we record the lookups we've
974 seen in the lookups field of the typed_declspecs nonterminal.
975 When we process the first declarator, either in parse_decl or
976 begin_function_definition, we call save_type_access_control,
977 which stores the lookups from the decl-specifier-seq in
978 current_type_lookups.
979 As we finish with each declarator, we process everything in type_lookups
980 via decl_type_access_control, which resets type_lookups to the value of
981 current_type_lookups for subsequent declarators.
982 When we enter a function, we set type_lookups to error_mark_node, so all
983 lookups are processed immediately. */
986 type_access_control (type, val)
989 if (val == NULL_TREE || TREE_CODE (val) != TYPE_DECL
990 || ! DECL_CLASS_SCOPE_P (val))
993 if (type_lookups == error_mark_node)
994 enforce_access (type, val);
995 else if (! accessible_p (type, val))
996 type_lookups = tree_cons (type, val, type_lookups);
999 /* DECL is a declaration from a base class of TYPE, which was the
1000 class used to name DECL. Return non-zero if, in the current
1001 context, DECL is accessible. If TYPE is actually a BINFO node,
1002 then we can tell in what context the access is occurring by looking
1003 at the most derived class along the path indicated by BINFO. */
1006 accessible_p (type, decl)
1014 /* Non-zero if it's OK to access DECL if it has protected
1015 accessibility in TYPE. */
1016 int protected_ok = 0;
1018 /* If we're not checking access, everything is accessible. */
1019 if (!flag_access_control)
1022 /* If this declaration is in a block or namespace scope, there's no
1024 if (!TYPE_P (context_for_name_lookup (decl)))
1030 type = BINFO_TYPE (type);
1033 binfo = TYPE_BINFO (type);
1035 /* [class.access.base]
1037 A member m is accessible when named in class N if
1039 --m as a member of N is public, or
1041 --m as a member of N is private, and the reference occurs in a
1042 member or friend of class N, or
1044 --m as a member of N is protected, and the reference occurs in a
1045 member or friend of class N, or in a member or friend of a
1046 class P derived from N, where m as a member of P is private or
1049 --there exists a base class B of N that is accessible at the point
1050 of reference, and m is accessible when named in class B.
1052 We walk the base class hierarchy, checking these conditions. */
1054 /* Figure out where the reference is occurring. Check to see if
1055 DECL is private or protected in this scope, since that will
1056 determine whether protected access is allowed. */
1057 if (current_class_type)
1058 protected_ok = protected_accessible_p (decl, current_class_type, binfo);
1060 /* Now, loop through the classes of which we are a friend. */
1062 protected_ok = friend_accessible_p (current_scope (), decl, binfo);
1064 /* Standardize the binfo that access_in_type will use. We don't
1065 need to know what path was chosen from this point onwards. */
1066 binfo = TYPE_BINFO (type);
1068 /* Compute the accessibility of DECL in the class hierarchy
1069 dominated by type. */
1070 access_in_type (type, decl);
1071 /* Walk the hierarchy again, looking for a base class that allows
1073 t = dfs_walk (binfo, dfs_accessible_p,
1074 dfs_accessible_queue_p,
1075 protected_ok ? &protected_ok : 0);
1076 /* Clear any mark bits. Note that we have to walk the whole tree
1077 here, since we have aborted the previous walk from some point
1078 deep in the tree. */
1079 dfs_walk (binfo, dfs_unmark, dfs_canonical_queue, 0);
1080 assert_canonical_unmarked (binfo);
1082 return t != NULL_TREE;
1085 /* Routine to see if the sub-object denoted by the binfo PARENT can be
1086 found as a base class and sub-object of the object denoted by
1087 BINFO. MOST_DERIVED is the most derived type of the hierarchy being
1091 is_subobject_of_p (parent, binfo, most_derived)
1092 tree parent, binfo, most_derived;
1097 if (parent == binfo)
1100 binfos = BINFO_BASETYPES (binfo);
1101 n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1103 /* Iterate the base types. */
1104 for (i = 0; i < n_baselinks; i++)
1106 tree base_binfo = TREE_VEC_ELT (binfos, i);
1107 if (!CLASS_TYPE_P (TREE_TYPE (base_binfo)))
1108 /* If we see a TEMPLATE_TYPE_PARM, or some such, as a base
1109 class there's no way to descend into it. */
1112 if (is_subobject_of_p (parent,
1113 CANONICAL_BINFO (base_binfo, most_derived),
1120 struct lookup_field_info {
1121 /* The type in which we're looking. */
1123 /* The name of the field for which we're looking. */
1125 /* If non-NULL, the current result of the lookup. */
1127 /* The path to RVAL. */
1129 /* If non-NULL, the lookup was ambiguous, and this is a list of the
1132 /* If non-zero, we are looking for types, not data members. */
1134 /* If non-zero, RVAL was found by looking through a dependent base. */
1135 int from_dep_base_p;
1136 /* If something went wrong, a message indicating what. */
1140 /* Returns non-zero if BINFO is not hidden by the value found by the
1141 lookup so far. If BINFO is hidden, then there's no need to look in
1142 it. DATA is really a struct lookup_field_info. Called from
1143 lookup_field via breadth_first_search. */
1146 lookup_field_queue_p (binfo, data)
1150 struct lookup_field_info *lfi = (struct lookup_field_info *) data;
1152 /* Don't look for constructors or destructors in base classes. */
1153 if (IDENTIFIER_CTOR_OR_DTOR_P (lfi->name))
1156 /* If this base class is hidden by the best-known value so far, we
1157 don't need to look. */
1158 if (!lfi->from_dep_base_p && lfi->rval_binfo
1159 && is_subobject_of_p (binfo, lfi->rval_binfo, lfi->type))
1162 return CANONICAL_BINFO (binfo, lfi->type);
1165 /* Within the scope of a template class, you can refer to the to the
1166 current specialization with the name of the template itself. For
1169 template <typename T> struct S { S* sp; }
1171 Returns non-zero if DECL is such a declaration in a class TYPE. */
1174 template_self_reference_p (type, decl)
1178 return (CLASSTYPE_USE_TEMPLATE (type)
1179 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
1180 && TREE_CODE (decl) == TYPE_DECL
1181 && DECL_ARTIFICIAL (decl)
1182 && DECL_NAME (decl) == constructor_name (type));
1186 /* Nonzero for a class member means that it is shared between all objects
1189 [class.member.lookup]:If the resulting set of declarations are not all
1190 from sub-objects of the same type, or the set has a nonstatic member
1191 and includes members from distinct sub-objects, there is an ambiguity
1192 and the program is ill-formed.
1194 This function checks that T contains no nonstatic members. */
1200 if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == TYPE_DECL \
1201 || TREE_CODE (t) == CONST_DECL)
1203 if (is_overloaded_fn (t))
1205 for (; t; t = OVL_NEXT (t))
1207 tree fn = OVL_CURRENT (t);
1208 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
1216 /* DATA is really a struct lookup_field_info. Look for a field with
1217 the name indicated there in BINFO. If this function returns a
1218 non-NULL value it is the result of the lookup. Called from
1219 lookup_field via breadth_first_search. */
1222 lookup_field_r (binfo, data)
1226 struct lookup_field_info *lfi = (struct lookup_field_info *) data;
1227 tree type = BINFO_TYPE (binfo);
1228 tree nval = NULL_TREE;
1229 int from_dep_base_p;
1231 /* First, look for a function. There can't be a function and a data
1232 member with the same name, and if there's a function and a type
1233 with the same name, the type is hidden by the function. */
1234 if (!lfi->want_type)
1236 int idx = lookup_fnfields_1 (type, lfi->name);
1238 nval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), idx);
1242 /* Look for a data member or type. */
1243 nval = lookup_field_1 (type, lfi->name);
1245 /* If there is no declaration with the indicated name in this type,
1246 then there's nothing to do. */
1250 /* If we're looking up a type (as with an elaborated type specifier)
1251 we ignore all non-types we find. */
1252 if (lfi->want_type && TREE_CODE (nval) != TYPE_DECL
1253 && !DECL_CLASS_TEMPLATE_P (nval))
1255 if (lfi->name == TYPE_IDENTIFIER (type))
1257 /* If the aggregate has no user defined constructors, we allow
1258 it to have fields with the same name as the enclosing type.
1259 If we are looking for that name, find the corresponding
1261 for (nval = TREE_CHAIN (nval); nval; nval = TREE_CHAIN (nval))
1262 if (DECL_NAME (nval) == lfi->name
1263 && TREE_CODE (nval) == TYPE_DECL)
1270 nval = purpose_member (lfi->name, CLASSTYPE_TAGS (type));
1272 nval = TYPE_MAIN_DECL (TREE_VALUE (nval));
1278 /* You must name a template base class with a template-id. */
1279 if (!same_type_p (type, lfi->type)
1280 && template_self_reference_p (type, nval))
1283 from_dep_base_p = dependent_base_p (binfo);
1284 if (lfi->from_dep_base_p && !from_dep_base_p)
1286 /* If the new declaration is not found via a dependent base, and
1287 the old one was, then we must prefer the new one. We weren't
1288 really supposed to be able to find the old one, so we don't
1289 want to be affected by a specialization. Consider:
1291 struct B { typedef int I; };
1292 template <typename T> struct D1 : virtual public B {};
1293 template <typename T> struct D :
1294 public D1, virtual pubic B { I i; };
1296 The `I' in `D<T>' is unambigousuly `B::I', regardless of how
1297 D1 is specialized. */
1298 lfi->from_dep_base_p = 0;
1299 lfi->rval = NULL_TREE;
1300 lfi->rval_binfo = NULL_TREE;
1301 lfi->ambiguous = NULL_TREE;
1304 else if (lfi->rval_binfo && !lfi->from_dep_base_p && from_dep_base_p)
1305 /* Similarly, if the old declaration was not found via a dependent
1306 base, and the new one is, ignore the new one. */
1309 /* If the lookup already found a match, and the new value doesn't
1310 hide the old one, we might have an ambiguity. */
1311 if (lfi->rval_binfo && !is_subobject_of_p (lfi->rval_binfo, binfo, lfi->type))
1313 if (nval == lfi->rval && shared_member_p (nval))
1314 /* The two things are really the same. */
1316 else if (is_subobject_of_p (binfo, lfi->rval_binfo, lfi->type))
1317 /* The previous value hides the new one. */
1321 /* We have a real ambiguity. We keep a chain of all the
1323 if (!lfi->ambiguous && lfi->rval)
1325 /* This is the first time we noticed an ambiguity. Add
1326 what we previously thought was a reasonable candidate
1328 lfi->ambiguous = tree_cons (NULL_TREE, lfi->rval, NULL_TREE);
1329 TREE_TYPE (lfi->ambiguous) = error_mark_node;
1332 /* Add the new value. */
1333 lfi->ambiguous = tree_cons (NULL_TREE, nval, lfi->ambiguous);
1334 TREE_TYPE (lfi->ambiguous) = error_mark_node;
1335 lfi->errstr = "request for member `%D' is ambiguous";
1340 if (from_dep_base_p && TREE_CODE (nval) != TYPE_DECL
1341 /* We need to return a member template class so we can
1342 define partial specializations. Is there a better
1344 && !DECL_CLASS_TEMPLATE_P (nval))
1345 /* The thing we're looking for isn't a type, so the implicit
1346 typename extension doesn't apply, so we just pretend we
1347 didn't find anything. */
1351 lfi->from_dep_base_p = from_dep_base_p;
1352 lfi->rval_binfo = binfo;
1358 /* Look for a member named NAME in an inheritance lattice dominated by
1359 XBASETYPE. If PROTECT is 0 or two, we do not check access. If it is
1360 1, we enforce accessibility. If PROTECT is zero, then, for an
1361 ambiguous lookup, we return NULL. If PROTECT is 1, we issue an
1362 error message. If PROTECT is 2, we return a TREE_LIST whose
1363 TREE_TYPE is error_mark_node and whose TREE_VALUEs are the list of
1364 ambiguous candidates.
1366 WANT_TYPE is 1 when we should only return TYPE_DECLs, if no
1367 TYPE_DECL can be found return NULL_TREE. */
1370 lookup_member (xbasetype, name, protect, want_type)
1371 register tree xbasetype, name;
1372 int protect, want_type;
1374 tree rval, rval_binfo = NULL_TREE;
1375 tree type = NULL_TREE, basetype_path = NULL_TREE;
1376 struct lookup_field_info lfi;
1378 /* rval_binfo is the binfo associated with the found member, note,
1379 this can be set with useful information, even when rval is not
1380 set, because it must deal with ALL members, not just non-function
1381 members. It is used for ambiguity checking and the hidden
1382 checks. Whereas rval is only set if a proper (not hidden)
1383 non-function member is found. */
1385 const char *errstr = 0;
1387 if (xbasetype == current_class_type && TYPE_BEING_DEFINED (xbasetype)
1388 && IDENTIFIER_CLASS_VALUE (name))
1390 tree field = IDENTIFIER_CLASS_VALUE (name);
1391 if (TREE_CODE (field) != FUNCTION_DECL
1392 && ! (want_type && TREE_CODE (field) != TYPE_DECL))
1393 /* We're in the scope of this class, and the value has already
1394 been looked up. Just return the cached value. */
1398 if (TREE_CODE (xbasetype) == TREE_VEC)
1400 type = BINFO_TYPE (xbasetype);
1401 basetype_path = xbasetype;
1403 else if (IS_AGGR_TYPE_CODE (TREE_CODE (xbasetype)))
1406 basetype_path = TYPE_BINFO (type);
1407 my_friendly_assert (BINFO_INHERITANCE_CHAIN (basetype_path) == NULL_TREE,
1413 complete_type (type);
1415 #ifdef GATHER_STATISTICS
1416 n_calls_lookup_field++;
1417 #endif /* GATHER_STATISTICS */
1419 memset ((PTR) &lfi, 0, sizeof (lfi));
1422 lfi.want_type = want_type;
1423 bfs_walk (basetype_path, &lookup_field_r, &lookup_field_queue_p, &lfi);
1425 rval_binfo = lfi.rval_binfo;
1427 type = BINFO_TYPE (rval_binfo);
1428 errstr = lfi.errstr;
1430 /* If we are not interested in ambiguities, don't report them;
1431 just return NULL_TREE. */
1432 if (!protect && lfi.ambiguous)
1438 return lfi.ambiguous;
1445 In the case of overloaded function names, access control is
1446 applied to the function selected by overloaded resolution. */
1447 if (rval && protect && !is_overloaded_fn (rval)
1448 && !enforce_access (xbasetype, rval))
1449 return error_mark_node;
1451 if (errstr && protect)
1453 error (errstr, name, type);
1455 print_candidates (lfi.ambiguous);
1456 rval = error_mark_node;
1459 /* If the thing we found was found via the implicit typename
1460 extension, build the typename type. */
1461 if (rval && lfi.from_dep_base_p && !DECL_CLASS_TEMPLATE_P (rval))
1462 rval = TYPE_STUB_DECL (build_typename_type (BINFO_TYPE (basetype_path),
1466 if (rval && is_overloaded_fn (rval))
1468 /* Note that the binfo we put in the baselink is the binfo where
1469 we found the functions, which we need for overload
1470 resolution, but which should not be passed to enforce_access;
1471 rather, enforce_access wants a binfo which refers to the
1472 scope in which we started looking for the function. This
1473 will generally be the binfo passed into this function as
1476 rval = tree_cons (rval_binfo, rval, NULL_TREE);
1477 SET_BASELINK_P (rval);
1483 /* Like lookup_member, except that if we find a function member we
1484 return NULL_TREE. */
1487 lookup_field (xbasetype, name, protect, want_type)
1488 register tree xbasetype, name;
1489 int protect, want_type;
1491 tree rval = lookup_member (xbasetype, name, protect, want_type);
1493 /* Ignore functions. */
1494 if (rval && TREE_CODE (rval) == TREE_LIST)
1500 /* Like lookup_member, except that if we find a non-function member we
1501 return NULL_TREE. */
1504 lookup_fnfields (xbasetype, name, protect)
1505 register tree xbasetype, name;
1508 tree rval = lookup_member (xbasetype, name, protect, /*want_type=*/0);
1510 /* Ignore non-functions. */
1511 if (rval && TREE_CODE (rval) != TREE_LIST)
1517 /* TYPE is a class type. Return the index of the fields within
1518 the method vector with name NAME, or -1 is no such field exists. */
1521 lookup_fnfields_1 (type, name)
1524 tree method_vec = (CLASS_TYPE_P (type)
1525 ? CLASSTYPE_METHOD_VEC (type)
1528 if (method_vec != 0)
1531 register tree *methods = &TREE_VEC_ELT (method_vec, 0);
1532 int len = TREE_VEC_LENGTH (method_vec);
1535 #ifdef GATHER_STATISTICS
1536 n_calls_lookup_fnfields_1++;
1537 #endif /* GATHER_STATISTICS */
1539 /* Constructors are first... */
1540 if (name == ctor_identifier)
1541 return (methods[CLASSTYPE_CONSTRUCTOR_SLOT]
1542 ? CLASSTYPE_CONSTRUCTOR_SLOT : -1);
1543 /* and destructors are second. */
1544 if (name == dtor_identifier)
1545 return (methods[CLASSTYPE_DESTRUCTOR_SLOT]
1546 ? CLASSTYPE_DESTRUCTOR_SLOT : -1);
1548 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
1549 i < len && methods[i];
1552 #ifdef GATHER_STATISTICS
1553 n_outer_fields_searched++;
1554 #endif /* GATHER_STATISTICS */
1556 tmp = OVL_CURRENT (methods[i]);
1557 if (DECL_NAME (tmp) == name)
1560 /* If the type is complete and we're past the conversion ops,
1561 switch to binary search. */
1562 if (! DECL_CONV_FN_P (tmp)
1563 && COMPLETE_TYPE_P (type))
1565 int lo = i + 1, hi = len;
1571 #ifdef GATHER_STATISTICS
1572 n_outer_fields_searched++;
1573 #endif /* GATHER_STATISTICS */
1575 tmp = DECL_NAME (OVL_CURRENT (methods[i]));
1579 else if (tmp < name)
1588 /* If we didn't find it, it might have been a template
1589 conversion operator to a templated type. If there are any,
1590 such template conversion operators will all be overloaded on
1591 the first conversion slot. (Note that we don't look for this
1592 case above so that we will always find specializations
1594 if (IDENTIFIER_TYPENAME_P (name))
1596 i = CLASSTYPE_FIRST_CONVERSION_SLOT;
1597 if (i < len && methods[i])
1599 tmp = OVL_CURRENT (methods[i]);
1600 if (TREE_CODE (tmp) == TEMPLATE_DECL
1601 && DECL_TEMPLATE_CONV_FN_P (tmp))
1610 /* Walk the class hierarchy dominated by TYPE. FN is called for each
1611 type in the hierarchy, in a breadth-first preorder traversal.
1612 If it ever returns a non-NULL value, that value is immediately
1613 returned and the walk is terminated. At each node, FN is passed a
1614 BINFO indicating the path from the curently visited base-class to
1615 TYPE. Before each base-class is walked QFN is called. If the
1616 value returned is non-zero, the base-class is walked; otherwise it
1617 is not. If QFN is NULL, it is treated as a function which always
1618 returns 1. Both FN and QFN are passed the DATA whenever they are
1622 bfs_walk (binfo, fn, qfn, data)
1624 tree (*fn) PARAMS ((tree, void *));
1625 tree (*qfn) PARAMS ((tree, void *));
1630 tree rval = NULL_TREE;
1631 /* An array of the base classes of BINFO. These will be built up in
1632 breadth-first order, except where QFN prunes the search. */
1633 varray_type bfs_bases;
1635 /* Start with enough room for ten base classes. That will be enough
1636 for most hierarchies. */
1637 VARRAY_TREE_INIT (bfs_bases, 10, "search_stack");
1639 /* Put the first type into the stack. */
1640 VARRAY_TREE (bfs_bases, 0) = binfo;
1643 for (head = 0; head < tail; ++head)
1649 /* Pull the next type out of the queue. */
1650 binfo = VARRAY_TREE (bfs_bases, head);
1652 /* If this is the one we're looking for, we're done. */
1653 rval = (*fn) (binfo, data);
1657 /* Queue up the base types. */
1658 binfos = BINFO_BASETYPES (binfo);
1659 n_baselinks = binfos ? TREE_VEC_LENGTH (binfos): 0;
1660 for (i = 0; i < n_baselinks; i++)
1662 tree base_binfo = TREE_VEC_ELT (binfos, i);
1665 base_binfo = (*qfn) (base_binfo, data);
1669 if (tail == VARRAY_SIZE (bfs_bases))
1670 VARRAY_GROW (bfs_bases, 2 * VARRAY_SIZE (bfs_bases));
1671 VARRAY_TREE (bfs_bases, tail) = base_binfo;
1678 VARRAY_FREE (bfs_bases);
1683 /* Exactly like bfs_walk, except that a depth-first traversal is
1684 performed, and PREFN is called in preorder, while POSTFN is called
1688 dfs_walk_real (binfo, prefn, postfn, qfn, data)
1690 tree (*prefn) PARAMS ((tree, void *));
1691 tree (*postfn) PARAMS ((tree, void *));
1692 tree (*qfn) PARAMS ((tree, void *));
1698 tree rval = NULL_TREE;
1700 /* Call the pre-order walking function. */
1703 rval = (*prefn) (binfo, data);
1708 /* Process the basetypes. */
1709 binfos = BINFO_BASETYPES (binfo);
1710 n_baselinks = BINFO_N_BASETYPES (binfo);
1711 for (i = 0; i < n_baselinks; i++)
1713 tree base_binfo = TREE_VEC_ELT (binfos, i);
1716 base_binfo = (*qfn) (base_binfo, data);
1720 rval = dfs_walk_real (base_binfo, prefn, postfn, qfn, data);
1726 /* Call the post-order walking function. */
1728 rval = (*postfn) (binfo, data);
1733 /* Exactly like bfs_walk, except that a depth-first post-order traversal is
1737 dfs_walk (binfo, fn, qfn, data)
1739 tree (*fn) PARAMS ((tree, void *));
1740 tree (*qfn) PARAMS ((tree, void *));
1743 return dfs_walk_real (binfo, 0, fn, qfn, data);
1746 /* Returns > 0 if a function with type DRETTYPE overriding a function
1747 with type BRETTYPE is covariant, as defined in [class.virtual].
1749 Returns 1 if trivial covariance, 2 if non-trivial (requiring runtime
1750 adjustment), or -1 if pedantically invalid covariance. */
1753 covariant_return_p (brettype, drettype)
1754 tree brettype, drettype;
1759 if (TREE_CODE (brettype) == FUNCTION_DECL)
1761 brettype = TREE_TYPE (TREE_TYPE (brettype));
1762 drettype = TREE_TYPE (TREE_TYPE (drettype));
1764 else if (TREE_CODE (brettype) == METHOD_TYPE)
1766 brettype = TREE_TYPE (brettype);
1767 drettype = TREE_TYPE (drettype);
1770 if (same_type_p (brettype, drettype))
1773 if (! (TREE_CODE (brettype) == TREE_CODE (drettype)
1774 && (TREE_CODE (brettype) == POINTER_TYPE
1775 || TREE_CODE (brettype) == REFERENCE_TYPE)
1776 && TYPE_QUALS (brettype) == TYPE_QUALS (drettype)))
1779 if (! can_convert (brettype, drettype))
1782 brettype = TREE_TYPE (brettype);
1783 drettype = TREE_TYPE (drettype);
1785 /* If not pedantic, allow any standard pointer conversion. */
1786 if (! IS_AGGR_TYPE (drettype) || ! IS_AGGR_TYPE (brettype))
1789 binfo = lookup_base (drettype, brettype, ba_check | ba_quiet, &kind);
1793 if (BINFO_OFFSET_ZEROP (binfo) && kind != bk_via_virtual)
1798 /* Check that virtual overrider OVERRIDER is acceptable for base function
1799 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
1802 check_final_overrider (overrider, basefn)
1803 tree overrider, basefn;
1805 tree over_type = TREE_TYPE (overrider);
1806 tree base_type = TREE_TYPE (basefn);
1807 tree over_return = TREE_TYPE (over_type);
1808 tree base_return = TREE_TYPE (base_type);
1809 tree over_throw = TYPE_RAISES_EXCEPTIONS (over_type);
1810 tree base_throw = TYPE_RAISES_EXCEPTIONS (base_type);
1813 if (same_type_p (base_return, over_return))
1815 else if ((i = covariant_return_p (base_return, over_return)))
1818 sorry ("adjusting pointers for covariant returns");
1820 if (pedantic && i == -1)
1822 cp_pedwarn_at ("invalid covariant return type for `%#D'", overrider);
1823 cp_pedwarn_at (" overriding `%#D' (must be pointer or reference to class)", basefn);
1826 else if (IS_AGGR_TYPE_2 (base_return, over_return)
1827 && same_or_base_type_p (base_return, over_return))
1829 cp_error_at ("invalid covariant return type for `%#D'", overrider);
1830 cp_error_at (" overriding `%#D' (must use pointer or reference)", basefn);
1833 else if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (overrider)) == NULL_TREE)
1835 cp_error_at ("conflicting return type specified for `%#D'", overrider);
1836 cp_error_at (" overriding `%#D'", basefn);
1837 SET_IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (overrider),
1838 DECL_CONTEXT (overrider));
1842 /* Check throw specifier is subset. */
1843 if (!comp_except_specs (base_throw, over_throw, 0))
1845 cp_error_at ("looser throw specifier for `%#F'", overrider);
1846 cp_error_at (" overriding `%#F'", basefn);
1852 /* Given a class TYPE, and a function decl FNDECL, look for
1853 virtual functions in TYPE's hierarchy which FNDECL overrides.
1854 We do not look in TYPE itself, only its bases.
1856 Returns non-zero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
1857 find that it overrides anything.
1859 We check that every function which is overridden, is correctly
1863 look_for_overrides (type, fndecl)
1866 tree binfo = TYPE_BINFO (type);
1867 tree basebinfos = BINFO_BASETYPES (binfo);
1868 int nbasebinfos = basebinfos ? TREE_VEC_LENGTH (basebinfos) : 0;
1872 for (ix = 0; ix != nbasebinfos; ix++)
1874 tree basetype = BINFO_TYPE (TREE_VEC_ELT (basebinfos, ix));
1876 if (TYPE_POLYMORPHIC_P (basetype))
1877 found += look_for_overrides_r (basetype, fndecl);
1882 /* Look in TYPE for virtual functions with the same signature as FNDECL.
1883 This differs from get_matching_virtual in that it will only return
1884 a function from TYPE. */
1887 look_for_overrides_here (type, fndecl)
1892 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fndecl))
1893 ix = CLASSTYPE_DESTRUCTOR_SLOT;
1895 ix = lookup_fnfields_1 (type, DECL_NAME (fndecl));
1898 tree fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), ix);
1900 for (; fns; fns = OVL_NEXT (fns))
1902 tree fn = OVL_CURRENT (fns);
1904 if (!DECL_VIRTUAL_P (fn))
1905 /* Not a virtual. */;
1906 else if (DECL_CONTEXT (fn) != type)
1907 /* Introduced with a using declaration. */;
1908 else if (DECL_STATIC_FUNCTION_P (fndecl))
1910 tree btypes = TYPE_ARG_TYPES (TREE_TYPE (fn));
1911 tree dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1912 if (compparms (TREE_CHAIN (btypes), dtypes))
1915 else if (same_signature_p (fndecl, fn))
1922 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
1923 TYPE itself and its bases. */
1926 look_for_overrides_r (type, fndecl)
1929 tree fn = look_for_overrides_here (type, fndecl);
1932 if (DECL_STATIC_FUNCTION_P (fndecl))
1934 /* A static member function cannot match an inherited
1935 virtual member function. */
1936 cp_error_at ("`%#D' cannot be declared", fndecl);
1937 cp_error_at (" since `%#D' declared in base class", fn);
1941 /* It's definitely virtual, even if not explicitly set. */
1942 DECL_VIRTUAL_P (fndecl) = 1;
1943 check_final_overrider (fndecl, fn);
1948 /* We failed to find one declared in this class. Look in its bases. */
1949 return look_for_overrides (type, fndecl);
1952 /* A queue function to use with dfs_walk that only walks into
1953 canonical bases. DATA should be the type of the complete object,
1954 or a TREE_LIST whose TREE_PURPOSE is the type of the complete
1955 object. By using this function as a queue function, you will walk
1956 over exactly those BINFOs that actually exist in the complete
1957 object, including those for virtual base classes. If you
1958 SET_BINFO_MARKED for each binfo you process, you are further
1959 guaranteed that you will walk into each virtual base class exactly
1963 dfs_unmarked_real_bases_queue_p (binfo, data)
1967 if (TREE_VIA_VIRTUAL (binfo))
1969 tree type = (tree) data;
1971 if (TREE_CODE (type) == TREE_LIST)
1972 type = TREE_PURPOSE (type);
1973 binfo = binfo_for_vbase (BINFO_TYPE (binfo), type);
1975 return unmarkedp (binfo, NULL);
1978 /* Like dfs_unmarked_real_bases_queue_p but walks only into things
1979 that are marked, rather than unmarked. */
1982 dfs_marked_real_bases_queue_p (binfo, data)
1986 if (TREE_VIA_VIRTUAL (binfo))
1988 tree type = (tree) data;
1990 if (TREE_CODE (type) == TREE_LIST)
1991 type = TREE_PURPOSE (type);
1992 binfo = binfo_for_vbase (BINFO_TYPE (binfo), type);
1994 return markedp (binfo, NULL);
1997 /* A queue function that skips all virtual bases (and their
2001 dfs_skip_vbases (binfo, data)
2003 void *data ATTRIBUTE_UNUSED;
2005 if (TREE_VIA_VIRTUAL (binfo))
2011 /* Called via dfs_walk from dfs_get_pure_virtuals. */
2014 dfs_get_pure_virtuals (binfo, data)
2018 tree type = (tree) data;
2020 /* We're not interested in primary base classes; the derived class
2021 of which they are a primary base will contain the information we
2023 if (!BINFO_PRIMARY_P (binfo))
2027 for (virtuals = BINFO_VIRTUALS (binfo);
2029 virtuals = TREE_CHAIN (virtuals))
2030 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals)))
2031 CLASSTYPE_PURE_VIRTUALS (type)
2032 = tree_cons (NULL_TREE, BV_FN (virtuals),
2033 CLASSTYPE_PURE_VIRTUALS (type));
2036 SET_BINFO_MARKED (binfo);
2041 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
2044 get_pure_virtuals (type)
2049 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
2050 is going to be overridden. */
2051 CLASSTYPE_PURE_VIRTUALS (type) = NULL_TREE;
2052 /* Now, run through all the bases which are not primary bases, and
2053 collect the pure virtual functions. We look at the vtable in
2054 each class to determine what pure virtual functions are present.
2055 (A primary base is not interesting because the derived class of
2056 which it is a primary base will contain vtable entries for the
2057 pure virtuals in the base class. */
2058 dfs_walk (TYPE_BINFO (type), dfs_get_pure_virtuals,
2059 dfs_unmarked_real_bases_queue_p, type);
2060 dfs_walk (TYPE_BINFO (type), dfs_unmark,
2061 dfs_marked_real_bases_queue_p, type);
2063 /* Put the pure virtuals in dfs order. */
2064 CLASSTYPE_PURE_VIRTUALS (type) = nreverse (CLASSTYPE_PURE_VIRTUALS (type));
2066 for (vbases = CLASSTYPE_VBASECLASSES (type);
2068 vbases = TREE_CHAIN (vbases))
2072 for (virtuals = BINFO_VIRTUALS (TREE_VALUE (vbases));
2074 virtuals = TREE_CHAIN (virtuals))
2076 tree base_fndecl = BV_FN (virtuals);
2077 if (DECL_NEEDS_FINAL_OVERRIDER_P (base_fndecl))
2078 error ("`%#D' needs a final overrider", base_fndecl);
2083 /* DEPTH-FIRST SEARCH ROUTINES. */
2086 markedp (binfo, data)
2088 void *data ATTRIBUTE_UNUSED;
2090 return BINFO_MARKED (binfo) ? binfo : NULL_TREE;
2094 unmarkedp (binfo, data)
2096 void *data ATTRIBUTE_UNUSED;
2098 return !BINFO_MARKED (binfo) ? binfo : NULL_TREE;
2102 marked_vtable_pathp (binfo, data)
2104 void *data ATTRIBUTE_UNUSED;
2106 return BINFO_VTABLE_PATH_MARKED (binfo) ? binfo : NULL_TREE;
2110 unmarked_vtable_pathp (binfo, data)
2112 void *data ATTRIBUTE_UNUSED;
2114 return !BINFO_VTABLE_PATH_MARKED (binfo) ? binfo : NULL_TREE;
2118 marked_pushdecls_p (binfo, data)
2120 void *data ATTRIBUTE_UNUSED;
2122 return (CLASS_TYPE_P (BINFO_TYPE (binfo))
2123 && BINFO_PUSHDECLS_MARKED (binfo)) ? binfo : NULL_TREE;
2127 unmarked_pushdecls_p (binfo, data)
2129 void *data ATTRIBUTE_UNUSED;
2131 return (CLASS_TYPE_P (BINFO_TYPE (binfo))
2132 && !BINFO_PUSHDECLS_MARKED (binfo)) ? binfo : NULL_TREE;
2135 /* The worker functions for `dfs_walk'. These do not need to
2136 test anything (vis a vis marking) if they are paired with
2137 a predicate function (above). */
2140 dfs_unmark (binfo, data)
2142 void *data ATTRIBUTE_UNUSED;
2144 CLEAR_BINFO_MARKED (binfo);
2148 /* get virtual base class types.
2149 This adds type to the vbase_types list in reverse dfs order.
2150 Ordering is very important, so don't change it. */
2153 dfs_get_vbase_types (binfo, data)
2157 tree type = (tree) data;
2159 if (TREE_VIA_VIRTUAL (binfo))
2160 CLASSTYPE_VBASECLASSES (type)
2161 = tree_cons (BINFO_TYPE (binfo),
2163 CLASSTYPE_VBASECLASSES (type));
2164 SET_BINFO_MARKED (binfo);
2168 /* Called via dfs_walk from mark_primary_bases. Builds the
2169 inheritance graph order list of BINFOs. */
2172 dfs_build_inheritance_graph_order (binfo, data)
2176 tree *last_binfo = (tree *) data;
2179 TREE_CHAIN (*last_binfo) = binfo;
2180 *last_binfo = binfo;
2181 SET_BINFO_MARKED (binfo);
2185 /* Set CLASSTYPE_VBASECLASSES for TYPE. */
2188 get_vbase_types (type)
2193 CLASSTYPE_VBASECLASSES (type) = NULL_TREE;
2194 dfs_walk (TYPE_BINFO (type), dfs_get_vbase_types, unmarkedp, type);
2195 /* Rely upon the reverse dfs ordering from dfs_get_vbase_types, and now
2196 reverse it so that we get normal dfs ordering. */
2197 CLASSTYPE_VBASECLASSES (type) = nreverse (CLASSTYPE_VBASECLASSES (type));
2198 dfs_walk (TYPE_BINFO (type), dfs_unmark, markedp, 0);
2199 /* Thread the BINFOs in inheritance-graph order. */
2201 dfs_walk_real (TYPE_BINFO (type),
2202 dfs_build_inheritance_graph_order,
2206 dfs_walk (TYPE_BINFO (type), dfs_unmark, markedp, NULL);
2209 /* Called from find_vbase_instance via dfs_walk. */
2212 dfs_find_vbase_instance (binfo, data)
2216 tree base = TREE_VALUE ((tree) data);
2218 if (BINFO_PRIMARY_P (binfo)
2219 && same_type_p (BINFO_TYPE (binfo), base))
2225 /* Find the real occurrence of the virtual BASE (a class type) in the
2226 hierarchy dominated by TYPE. */
2229 find_vbase_instance (base, type)
2235 instance = binfo_for_vbase (base, type);
2236 if (!BINFO_PRIMARY_P (instance))
2239 return dfs_walk (TYPE_BINFO (type),
2240 dfs_find_vbase_instance,
2242 build_tree_list (type, base));
2246 /* Debug info for C++ classes can get very large; try to avoid
2247 emitting it everywhere.
2249 Note that this optimization wins even when the target supports
2250 BINCL (if only slightly), and reduces the amount of work for the
2254 maybe_suppress_debug_info (t)
2257 /* We can't do the usual TYPE_DECL_SUPPRESS_DEBUG thing with DWARF, which
2258 does not support name references between translation units. It supports
2259 symbolic references between translation units, but only within a single
2260 executable or shared library.
2262 For DWARF 2, we handle TYPE_DECL_SUPPRESS_DEBUG by pretending
2263 that the type was never defined, so we only get the members we
2265 if (write_symbols == DWARF_DEBUG || write_symbols == NO_DEBUG)
2268 /* We might have set this earlier in cp_finish_decl. */
2269 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 0;
2271 /* If we already know how we're handling this class, handle debug info
2273 if (CLASSTYPE_INTERFACE_KNOWN (t))
2275 if (CLASSTYPE_INTERFACE_ONLY (t))
2276 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
2277 /* else don't set it. */
2279 /* If the class has a vtable, write out the debug info along with
2281 else if (TYPE_CONTAINS_VPTR_P (t))
2282 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
2284 /* Otherwise, just emit the debug info normally. */
2287 /* Note that we want debugging information for a base class of a class
2288 whose vtable is being emitted. Normally, this would happen because
2289 calling the constructor for a derived class implies calling the
2290 constructors for all bases, which involve initializing the
2291 appropriate vptr with the vtable for the base class; but in the
2292 presence of optimization, this initialization may be optimized
2293 away, so we tell finish_vtable_vardecl that we want the debugging
2294 information anyway. */
2297 dfs_debug_mark (binfo, data)
2299 void *data ATTRIBUTE_UNUSED;
2301 tree t = BINFO_TYPE (binfo);
2303 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
2308 /* Returns BINFO if we haven't already noted that we want debugging
2309 info for this base class. */
2312 dfs_debug_unmarkedp (binfo, data)
2314 void *data ATTRIBUTE_UNUSED;
2316 return (!CLASSTYPE_DEBUG_REQUESTED (BINFO_TYPE (binfo))
2317 ? binfo : NULL_TREE);
2320 /* Write out the debugging information for TYPE, whose vtable is being
2321 emitted. Also walk through our bases and note that we want to
2322 write out information for them. This avoids the problem of not
2323 writing any debug info for intermediate basetypes whose
2324 constructors, and thus the references to their vtables, and thus
2325 the vtables themselves, were optimized away. */
2328 note_debug_info_needed (type)
2331 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
2333 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)) = 0;
2334 rest_of_type_compilation (type, toplevel_bindings_p ());
2337 dfs_walk (TYPE_BINFO (type), dfs_debug_mark, dfs_debug_unmarkedp, 0);
2340 /* Subroutines of push_class_decls (). */
2342 /* Returns 1 iff BINFO is a base we shouldn't really be able to see into,
2343 because it (or one of the intermediate bases) depends on template parms. */
2346 dependent_base_p (binfo)
2349 for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
2351 if (currently_open_class (TREE_TYPE (binfo)))
2353 if (uses_template_parms (TREE_TYPE (binfo)))
2360 setup_class_bindings (name, type_binding_p)
2364 tree type_binding = NULL_TREE;
2367 /* If we've already done the lookup for this declaration, we're
2369 if (IDENTIFIER_CLASS_VALUE (name))
2372 /* First, deal with the type binding. */
2375 type_binding = lookup_member (current_class_type, name,
2378 if (TREE_CODE (type_binding) == TREE_LIST
2379 && TREE_TYPE (type_binding) == error_mark_node)
2380 /* NAME is ambiguous. */
2381 push_class_level_binding (name, type_binding);
2383 pushdecl_class_level (type_binding);
2386 /* Now, do the value binding. */
2387 value_binding = lookup_member (current_class_type, name,
2392 && (TREE_CODE (value_binding) == TYPE_DECL
2393 || (TREE_CODE (value_binding) == TREE_LIST
2394 && TREE_TYPE (value_binding) == error_mark_node
2395 && (TREE_CODE (TREE_VALUE (value_binding))
2397 /* We found a type-binding, even when looking for a non-type
2398 binding. This means that we already processed this binding
2400 my_friendly_assert (type_binding_p, 19990401);
2401 else if (value_binding)
2403 if (TREE_CODE (value_binding) == TREE_LIST
2404 && TREE_TYPE (value_binding) == error_mark_node)
2405 /* NAME is ambiguous. */
2406 push_class_level_binding (name, value_binding);
2409 if (BASELINK_P (value_binding))
2410 /* NAME is some overloaded functions. */
2411 value_binding = TREE_VALUE (value_binding);
2412 pushdecl_class_level (value_binding);
2417 /* Push class-level declarations for any names appearing in BINFO that
2421 dfs_push_type_decls (binfo, data)
2423 void *data ATTRIBUTE_UNUSED;
2428 type = BINFO_TYPE (binfo);
2429 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2430 if (DECL_NAME (fields) && TREE_CODE (fields) == TYPE_DECL
2431 && !(!same_type_p (type, current_class_type)
2432 && template_self_reference_p (type, fields)))
2433 setup_class_bindings (DECL_NAME (fields), /*type_binding_p=*/1);
2435 /* We can't just use BINFO_MARKED because envelope_add_decl uses
2436 DERIVED_FROM_P, which calls get_base_distance. */
2437 SET_BINFO_PUSHDECLS_MARKED (binfo);
2442 /* Push class-level declarations for any names appearing in BINFO that
2443 are not TYPE_DECLS. */
2446 dfs_push_decls (binfo, data)
2454 type = BINFO_TYPE (binfo);
2455 dep_base_p = (processing_template_decl && type != current_class_type
2456 && dependent_base_p (binfo));
2460 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2461 if (DECL_NAME (fields)
2462 && TREE_CODE (fields) != TYPE_DECL
2463 && TREE_CODE (fields) != USING_DECL)
2464 setup_class_bindings (DECL_NAME (fields), /*type_binding_p=*/0);
2465 else if (TREE_CODE (fields) == FIELD_DECL
2466 && ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
2467 dfs_push_decls (TYPE_BINFO (TREE_TYPE (fields)), data);
2469 method_vec = (CLASS_TYPE_P (type)
2470 ? CLASSTYPE_METHOD_VEC (type) : NULL_TREE);
2476 /* Farm out constructors and destructors. */
2477 end = TREE_VEC_END (method_vec);
2479 for (methods = &TREE_VEC_ELT (method_vec, 2);
2480 *methods && methods != end;
2482 setup_class_bindings (DECL_NAME (OVL_CURRENT (*methods)),
2483 /*type_binding_p=*/0);
2487 CLEAR_BINFO_PUSHDECLS_MARKED (binfo);
2492 /* When entering the scope of a class, we cache all of the
2493 fields that that class provides within its inheritance
2494 lattice. Where ambiguities result, we mark them
2495 with `error_mark_node' so that if they are encountered
2496 without explicit qualification, we can emit an error
2500 push_class_decls (type)
2503 search_stack = push_search_level (search_stack, &search_obstack);
2505 /* Enter type declarations and mark. */
2506 dfs_walk (TYPE_BINFO (type), dfs_push_type_decls, unmarked_pushdecls_p, 0);
2508 /* Enter non-type declarations and unmark. */
2509 dfs_walk (TYPE_BINFO (type), dfs_push_decls, marked_pushdecls_p, 0);
2512 /* Here's a subroutine we need because C lacks lambdas. */
2515 dfs_unuse_fields (binfo, data)
2517 void *data ATTRIBUTE_UNUSED;
2519 tree type = TREE_TYPE (binfo);
2522 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2524 if (TREE_CODE (fields) != FIELD_DECL)
2527 TREE_USED (fields) = 0;
2528 if (DECL_NAME (fields) == NULL_TREE
2529 && ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
2530 unuse_fields (TREE_TYPE (fields));
2540 dfs_walk (TYPE_BINFO (type), dfs_unuse_fields, unmarkedp, 0);
2546 /* We haven't pushed a search level when dealing with cached classes,
2547 so we'd better not try to pop it. */
2549 search_stack = pop_search_level (search_stack);
2553 print_search_statistics ()
2555 #ifdef GATHER_STATISTICS
2556 fprintf (stderr, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
2557 n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1);
2558 fprintf (stderr, "%d fnfields searched in %d calls to lookup_fnfields\n",
2559 n_outer_fields_searched, n_calls_lookup_fnfields);
2560 fprintf (stderr, "%d calls to get_base_type\n", n_calls_get_base_type);
2561 #else /* GATHER_STATISTICS */
2562 fprintf (stderr, "no search statistics\n");
2563 #endif /* GATHER_STATISTICS */
2567 init_search_processing ()
2569 gcc_obstack_init (&search_obstack);
2573 reinit_search_statistics ()
2575 #ifdef GATHER_STATISTICS
2576 n_fields_searched = 0;
2577 n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0;
2578 n_calls_lookup_fnfields = 0, n_calls_lookup_fnfields_1 = 0;
2579 n_calls_get_base_type = 0;
2580 n_outer_fields_searched = 0;
2581 n_contexts_saved = 0;
2582 #endif /* GATHER_STATISTICS */
2586 add_conversions (binfo, data)
2591 tree method_vec = CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo));
2592 tree *conversions = (tree *) data;
2594 /* Some builtin types have no method vector, not even an empty one. */
2598 for (i = 2; i < TREE_VEC_LENGTH (method_vec); ++i)
2600 tree tmp = TREE_VEC_ELT (method_vec, i);
2603 if (!tmp || ! DECL_CONV_FN_P (OVL_CURRENT (tmp)))
2606 name = DECL_NAME (OVL_CURRENT (tmp));
2608 /* Make sure we don't already have this conversion. */
2609 if (! IDENTIFIER_MARKED (name))
2611 *conversions = tree_cons (binfo, tmp, *conversions);
2612 IDENTIFIER_MARKED (name) = 1;
2618 /* Return a TREE_LIST containing all the non-hidden user-defined
2619 conversion functions for TYPE (and its base-classes). The
2620 TREE_VALUE of each node is a FUNCTION_DECL or an OVERLOAD
2621 containing the conversion functions. The TREE_PURPOSE is the BINFO
2622 from which the conversion functions in this node were selected. */
2625 lookup_conversions (type)
2629 tree conversions = NULL_TREE;
2631 if (COMPLETE_TYPE_P (type))
2632 bfs_walk (TYPE_BINFO (type), add_conversions, 0, &conversions);
2634 for (t = conversions; t; t = TREE_CHAIN (t))
2635 IDENTIFIER_MARKED (DECL_NAME (OVL_CURRENT (TREE_VALUE (t)))) = 0;
2646 /* Check whether the empty class indicated by EMPTY_BINFO is also present
2647 at offset 0 in COMPARE_TYPE, and set found_overlap if so. */
2650 dfs_check_overlap (empty_binfo, data)
2654 struct overlap_info *oi = (struct overlap_info *) data;
2656 for (binfo = TYPE_BINFO (oi->compare_type);
2658 binfo = BINFO_BASETYPE (binfo, 0))
2660 if (BINFO_TYPE (binfo) == BINFO_TYPE (empty_binfo))
2662 oi->found_overlap = 1;
2665 else if (BINFO_BASETYPES (binfo) == NULL_TREE)
2672 /* Trivial function to stop base traversal when we find something. */
2675 dfs_no_overlap_yet (binfo, data)
2679 struct overlap_info *oi = (struct overlap_info *) data;
2680 return !oi->found_overlap ? binfo : NULL_TREE;
2683 /* Returns nonzero if EMPTY_TYPE or any of its bases can also be found at
2684 offset 0 in NEXT_TYPE. Used in laying out empty base class subobjects. */
2687 types_overlap_p (empty_type, next_type)
2688 tree empty_type, next_type;
2690 struct overlap_info oi;
2692 if (! IS_AGGR_TYPE (next_type))
2694 oi.compare_type = next_type;
2695 oi.found_overlap = 0;
2696 dfs_walk (TYPE_BINFO (empty_type), dfs_check_overlap,
2697 dfs_no_overlap_yet, &oi);
2698 return oi.found_overlap;
2701 /* Given a vtable VAR, determine which of the inherited classes the vtable
2702 inherits (in a loose sense) functions from.
2704 FIXME: This does not work with the new ABI. */
2707 binfo_for_vtable (var)
2710 tree main_binfo = TYPE_BINFO (DECL_CONTEXT (var));
2711 tree binfos = TYPE_BINFO_BASETYPES (BINFO_TYPE (main_binfo));
2712 int n_baseclasses = CLASSTYPE_N_BASECLASSES (BINFO_TYPE (main_binfo));
2715 for (i = 0; i < n_baseclasses; i++)
2717 tree base_binfo = TREE_VEC_ELT (binfos, i);
2718 if (base_binfo != NULL_TREE && BINFO_VTABLE (base_binfo) == var)
2722 /* If no secondary base classes matched, return the primary base, if
2724 if (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (main_binfo)))
2725 return get_primary_binfo (main_binfo);
2730 /* Returns the binfo of the first direct or indirect virtual base derived
2731 from BINFO, or NULL if binfo is not via virtual. */
2734 binfo_from_vbase (binfo)
2737 for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
2739 if (TREE_VIA_VIRTUAL (binfo))
2745 /* Returns the binfo of the first direct or indirect virtual base derived
2746 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2750 binfo_via_virtual (binfo, limit)
2754 for (; binfo && (!limit || !same_type_p (BINFO_TYPE (binfo), limit));
2755 binfo = BINFO_INHERITANCE_CHAIN (binfo))
2757 if (TREE_VIA_VIRTUAL (binfo))
2763 /* Returns the BINFO (if any) for the virtual baseclass T of the class
2764 C from the CLASSTYPE_VBASECLASSES list. */
2767 binfo_for_vbase (basetype, classtype)
2773 binfo = purpose_member (basetype, CLASSTYPE_VBASECLASSES (classtype));
2774 return binfo ? TREE_VALUE (binfo) : NULL_TREE;