1 /* Breadth-first and depth-first routines for
2 searching multiple-inheritance lattice for GNU C++.
3 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC 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 GCC 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 GCC; 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. */
28 #include "coretypes.h"
39 static int is_subobject_of_p (tree
, tree
);
40 static tree
dfs_lookup_base (tree
, void *);
41 static tree
dfs_dcast_hint_pre (tree
, void *);
42 static tree
dfs_dcast_hint_post (tree
, void *);
43 static tree
dfs_debug_mark (tree
, void *);
44 static tree
dfs_walk_once_r (tree
, tree (*pre_fn
) (tree
, void *),
45 tree (*post_fn
) (tree
, void *), void *data
);
46 static void dfs_unmark_r (tree
);
47 static int check_hidden_convs (tree
, int, int, tree
, tree
, tree
);
48 static tree
split_conversions (tree
, tree
, tree
, tree
);
49 static int lookup_conversions_r (tree
, int, int,
50 tree
, tree
, tree
, tree
, tree
*, tree
*);
51 static int look_for_overrides_r (tree
, tree
);
52 static tree
lookup_field_r (tree
, void *);
53 static tree
dfs_accessible_post (tree
, void *);
54 static tree
dfs_walk_once_accessible_r (tree
, bool, bool,
55 tree (*pre_fn
) (tree
, void *),
56 tree (*post_fn
) (tree
, void *),
58 static tree
dfs_walk_once_accessible (tree
, bool,
59 tree (*pre_fn
) (tree
, void *),
60 tree (*post_fn
) (tree
, void *),
62 static tree
dfs_access_in_type (tree
, void *);
63 static access_kind
access_in_type (tree
, tree
);
64 static int protected_accessible_p (tree
, tree
, tree
);
65 static int friend_accessible_p (tree
, tree
, tree
);
66 static int template_self_reference_p (tree
, tree
);
67 static tree
dfs_get_pure_virtuals (tree
, void *);
70 /* Variables for gathering statistics. */
71 #ifdef GATHER_STATISTICS
72 static int n_fields_searched
;
73 static int n_calls_lookup_field
, n_calls_lookup_field_1
;
74 static int n_calls_lookup_fnfields
, n_calls_lookup_fnfields_1
;
75 static int n_calls_get_base_type
;
76 static int n_outer_fields_searched
;
77 static int n_contexts_saved
;
78 #endif /* GATHER_STATISTICS */
81 /* Data for lookup_base and its workers. */
83 struct lookup_base_data_s
85 tree t
; /* type being searched. */
86 tree base
; /* The base type we're looking for. */
87 tree binfo
; /* Found binfo. */
88 bool via_virtual
; /* Found via a virtual path. */
89 bool ambiguous
; /* Found multiply ambiguous */
90 bool repeated_base
; /* Whether there are repeated bases in the
92 bool want_any
; /* Whether we want any matching binfo. */
95 /* Worker function for lookup_base. See if we've found the desired
96 base and update DATA_ (a pointer to LOOKIP_BASE_DATA_S). */
99 dfs_lookup_base (tree binfo
, void *data_
)
101 struct lookup_base_data_s
*data
= data_
;
103 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->base
))
109 = binfo_via_virtual (data
->binfo
, data
->t
) != NULL_TREE
;
111 if (!data
->repeated_base
)
112 /* If there are no repeated bases, we can stop now. */
115 if (data
->want_any
&& !data
->via_virtual
)
116 /* If this is a non-virtual base, then we can't do
120 return dfs_skip_bases
;
124 gcc_assert (binfo
!= data
->binfo
);
126 /* We've found more than one matching binfo. */
129 /* This is immediately ambiguous. */
130 data
->binfo
= NULL_TREE
;
131 data
->ambiguous
= true;
132 return error_mark_node
;
135 /* Prefer one via a non-virtual path. */
136 if (!binfo_via_virtual (binfo
, data
->t
))
139 data
->via_virtual
= false;
143 /* There must be repeated bases, otherwise we'd have stopped
144 on the first base we found. */
145 return dfs_skip_bases
;
152 /* Returns true if type BASE is accessible in T. (BASE is known to be
153 a (possibly non-proper) base class of T.) */
156 accessible_base_p (tree t
, tree base
)
160 /* [class.access.base]
162 A base class is said to be accessible if an invented public
163 member of the base class is accessible.
165 If BASE is a non-proper base, this condition is trivially
167 if (same_type_p (t
, base
))
169 /* Rather than inventing a public member, we use the implicit
170 public typedef created in the scope of every class. */
171 decl
= TYPE_FIELDS (base
);
172 while (!DECL_SELF_REFERENCE_P (decl
))
173 decl
= TREE_CHAIN (decl
);
174 while (ANON_AGGR_TYPE_P (t
))
175 t
= TYPE_CONTEXT (t
);
176 return accessible_p (t
, decl
);
179 /* Lookup BASE in the hierarchy dominated by T. Do access checking as
180 ACCESS specifies. Return the binfo we discover. If KIND_PTR is
181 non-NULL, fill with information about what kind of base we
184 If the base is inaccessible, or ambiguous, and the ba_quiet bit is
185 not set in ACCESS, then an error is issued and error_mark_node is
186 returned. If the ba_quiet bit is set, then no error is issued and
187 NULL_TREE is returned. */
190 lookup_base (tree t
, tree base
, base_access access
, base_kind
*kind_ptr
)
196 if (t
== error_mark_node
|| base
== error_mark_node
)
199 *kind_ptr
= bk_not_base
;
200 return error_mark_node
;
202 gcc_assert (TYPE_P (base
));
211 t
= complete_type (TYPE_MAIN_VARIANT (t
));
212 t_binfo
= TYPE_BINFO (t
);
215 base
= complete_type (TYPE_MAIN_VARIANT (base
));
219 struct lookup_base_data_s data
;
223 data
.binfo
= NULL_TREE
;
224 data
.ambiguous
= data
.via_virtual
= false;
225 data
.repeated_base
= CLASSTYPE_REPEATED_BASE_P (t
);
226 data
.want_any
= access
== ba_any
;
228 dfs_walk_once (t_binfo
, dfs_lookup_base
, NULL
, &data
);
232 bk
= data
.ambiguous
? bk_ambig
: bk_not_base
;
233 else if (binfo
== t_binfo
)
235 else if (data
.via_virtual
)
246 /* Check that the base is unambiguous and accessible. */
247 if (access
!= ba_any
)
254 if (!(access
& ba_quiet
))
256 error ("%qT is an ambiguous base of %qT", base
, t
);
257 binfo
= error_mark_node
;
262 if ((access
& ~ba_quiet
) != ba_ignore
263 /* If BASE is incomplete, then BASE and TYPE are probably
264 the same, in which case BASE is accessible. If they
265 are not the same, then TYPE is invalid. In that case,
266 there's no need to issue another error here, and
267 there's no implicit typedef to use in the code that
268 follows, so we skip the check. */
269 && COMPLETE_TYPE_P (base
)
270 && !accessible_base_p (t
, base
))
272 if (!(access
& ba_quiet
))
274 error ("%qT is an inaccessible base of %qT", base
, t
);
275 binfo
= error_mark_node
;
279 bk
= bk_inaccessible
;
290 /* Data for dcast_base_hint walker. */
294 tree subtype
; /* The base type we're looking for. */
295 int virt_depth
; /* Number of virtual bases encountered from most
297 tree offset
; /* Best hint offset discovered so far. */
298 bool repeated_base
; /* Whether there are repeated bases in the
302 /* Worker for dcast_base_hint. Search for the base type being cast
306 dfs_dcast_hint_pre (tree binfo
, void *data_
)
308 struct dcast_data_s
*data
= data_
;
310 if (BINFO_VIRTUAL_P (binfo
))
313 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->subtype
))
315 if (data
->virt_depth
)
317 data
->offset
= ssize_int (-1);
321 data
->offset
= ssize_int (-3);
323 data
->offset
= BINFO_OFFSET (binfo
);
325 return data
->repeated_base
? dfs_skip_bases
: data
->offset
;
331 /* Worker for dcast_base_hint. Track the virtual depth. */
334 dfs_dcast_hint_post (tree binfo
, void *data_
)
336 struct dcast_data_s
*data
= data_
;
338 if (BINFO_VIRTUAL_P (binfo
))
344 /* The dynamic cast runtime needs a hint about how the static SUBTYPE type
345 started from is related to the required TARGET type, in order to optimize
346 the inheritance graph search. This information is independent of the
347 current context, and ignores private paths, hence get_base_distance is
348 inappropriate. Return a TREE specifying the base offset, BOFF.
349 BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
350 and there are no public virtual SUBTYPE bases.
351 BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
352 BOFF == -2, SUBTYPE is not a public base.
353 BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
356 dcast_base_hint (tree subtype
, tree target
)
358 struct dcast_data_s data
;
360 data
.subtype
= subtype
;
362 data
.offset
= NULL_TREE
;
363 data
.repeated_base
= CLASSTYPE_REPEATED_BASE_P (target
);
365 dfs_walk_once_accessible (TYPE_BINFO (target
), /*friends=*/false,
366 dfs_dcast_hint_pre
, dfs_dcast_hint_post
, &data
);
367 return data
.offset
? data
.offset
: ssize_int (-2);
370 /* Search for a member with name NAME in a multiple inheritance
371 lattice specified by TYPE. If it does not exist, return NULL_TREE.
372 If the member is ambiguously referenced, return `error_mark_node'.
373 Otherwise, return a DECL with the indicated name. If WANT_TYPE is
374 true, type declarations are preferred. */
376 /* Do a 1-level search for NAME as a member of TYPE. The caller must
377 figure out whether it can access this field. (Since it is only one
378 level, this is reasonable.) */
381 lookup_field_1 (tree type
, tree name
, bool want_type
)
385 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
386 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
387 || TREE_CODE (type
) == TYPENAME_TYPE
)
388 /* The TYPE_FIELDS of a TEMPLATE_TYPE_PARM and
389 BOUND_TEMPLATE_TEMPLATE_PARM are not fields at all;
390 instead TYPE_FIELDS is the TEMPLATE_PARM_INDEX. (Miraculously,
391 the code often worked even when we treated the index as a list
393 The TYPE_FIELDS of TYPENAME_TYPE is its TYPENAME_TYPE_FULLNAME. */
397 && DECL_LANG_SPECIFIC (TYPE_NAME (type
))
398 && DECL_SORTED_FIELDS (TYPE_NAME (type
)))
400 tree
*fields
= &DECL_SORTED_FIELDS (TYPE_NAME (type
))->elts
[0];
401 int lo
= 0, hi
= DECL_SORTED_FIELDS (TYPE_NAME (type
))->len
;
408 #ifdef GATHER_STATISTICS
410 #endif /* GATHER_STATISTICS */
412 if (DECL_NAME (fields
[i
]) > name
)
414 else if (DECL_NAME (fields
[i
]) < name
)
420 /* We might have a nested class and a field with the
421 same name; we sorted them appropriately via
422 field_decl_cmp, so just look for the first or last
423 field with this name. */
428 while (i
>= lo
&& DECL_NAME (fields
[i
]) == name
);
429 if (TREE_CODE (field
) != TYPE_DECL
430 && !DECL_CLASS_TEMPLATE_P (field
))
437 while (i
< hi
&& DECL_NAME (fields
[i
]) == name
);
445 field
= TYPE_FIELDS (type
);
447 #ifdef GATHER_STATISTICS
448 n_calls_lookup_field_1
++;
449 #endif /* GATHER_STATISTICS */
450 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
452 #ifdef GATHER_STATISTICS
454 #endif /* GATHER_STATISTICS */
455 gcc_assert (DECL_P (field
));
456 if (DECL_NAME (field
) == NULL_TREE
457 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
459 tree temp
= lookup_field_1 (TREE_TYPE (field
), name
, want_type
);
463 if (TREE_CODE (field
) == USING_DECL
)
465 /* We generally treat class-scope using-declarations as
466 ARM-style access specifications, because support for the
467 ISO semantics has not been implemented. So, in general,
468 there's no reason to return a USING_DECL, and the rest of
469 the compiler cannot handle that. Once the class is
470 defined, USING_DECLs are purged from TYPE_FIELDS; see
471 handle_using_decl. However, we make special efforts to
472 make using-declarations in template classes work
474 if (CLASSTYPE_TEMPLATE_INFO (type
)
475 && !CLASSTYPE_USE_TEMPLATE (type
)
476 && !TREE_TYPE (field
))
482 if (DECL_NAME (field
) == name
484 || TREE_CODE (field
) == TYPE_DECL
485 || DECL_CLASS_TEMPLATE_P (field
)))
489 if (name
== vptr_identifier
)
491 /* Give the user what s/he thinks s/he wants. */
492 if (TYPE_POLYMORPHIC_P (type
))
493 return TYPE_VFIELD (type
);
498 /* There are a number of cases we need to be aware of here:
499 current_class_type current_function_decl
506 Those last two make life interesting. If we're in a function which is
507 itself inside a class, we need decls to go into the fn's decls (our
508 second case below). But if we're in a class and the class itself is
509 inside a function, we need decls to go into the decls for the class. To
510 achieve this last goal, we must see if, when both current_class_ptr and
511 current_function_decl are set, the class was declared inside that
512 function. If so, we know to put the decls into the class's scope. */
517 if (current_function_decl
== NULL_TREE
)
518 return current_class_type
;
519 if (current_class_type
== NULL_TREE
)
520 return current_function_decl
;
521 if ((DECL_FUNCTION_MEMBER_P (current_function_decl
)
522 && same_type_p (DECL_CONTEXT (current_function_decl
),
524 || (DECL_FRIEND_CONTEXT (current_function_decl
)
525 && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl
),
526 current_class_type
)))
527 return current_function_decl
;
529 return current_class_type
;
532 /* Returns nonzero if we are currently in a function scope. Note
533 that this function returns zero if we are within a local class, but
534 not within a member function body of the local class. */
537 at_function_scope_p (void)
539 tree cs
= current_scope ();
540 return cs
&& TREE_CODE (cs
) == FUNCTION_DECL
;
543 /* Returns true if the innermost active scope is a class scope. */
546 at_class_scope_p (void)
548 tree cs
= current_scope ();
549 return cs
&& TYPE_P (cs
);
552 /* Returns true if the innermost active scope is a namespace scope. */
555 at_namespace_scope_p (void)
557 /* We are in a namespace scope if we are not it a class scope or a
559 return !current_scope();
562 /* Return the scope of DECL, as appropriate when doing name-lookup. */
565 context_for_name_lookup (tree decl
)
569 For the purposes of name lookup, after the anonymous union
570 definition, the members of the anonymous union are considered to
571 have been defined in the scope in which the anonymous union is
573 tree context
= DECL_CONTEXT (decl
);
575 while (context
&& TYPE_P (context
) && ANON_AGGR_TYPE_P (context
))
576 context
= TYPE_CONTEXT (context
);
578 context
= global_namespace
;
583 /* The accessibility routines use BINFO_ACCESS for scratch space
584 during the computation of the accessibility of some declaration. */
586 #define BINFO_ACCESS(NODE) \
587 ((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE)))
589 /* Set the access associated with NODE to ACCESS. */
591 #define SET_BINFO_ACCESS(NODE, ACCESS) \
592 ((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \
593 (TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0))
595 /* Called from access_in_type via dfs_walk. Calculate the access to
596 DATA (which is really a DECL) in BINFO. */
599 dfs_access_in_type (tree binfo
, void *data
)
601 tree decl
= (tree
) data
;
602 tree type
= BINFO_TYPE (binfo
);
603 access_kind access
= ak_none
;
605 if (context_for_name_lookup (decl
) == type
)
607 /* If we have descended to the scope of DECL, just note the
608 appropriate access. */
609 if (TREE_PRIVATE (decl
))
611 else if (TREE_PROTECTED (decl
))
612 access
= ak_protected
;
618 /* First, check for an access-declaration that gives us more
619 access to the DECL. The CONST_DECL for an enumeration
620 constant will not have DECL_LANG_SPECIFIC, and thus no
622 if (DECL_LANG_SPECIFIC (decl
) && !DECL_DISCRIMINATOR_P (decl
))
624 tree decl_access
= purpose_member (type
, DECL_ACCESS (decl
));
628 decl_access
= TREE_VALUE (decl_access
);
630 if (decl_access
== access_public_node
)
632 else if (decl_access
== access_protected_node
)
633 access
= ak_protected
;
634 else if (decl_access
== access_private_node
)
645 VEC (tree
) *accesses
;
647 /* Otherwise, scan our baseclasses, and pick the most favorable
649 accesses
= BINFO_BASE_ACCESSES (binfo
);
650 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
652 tree base_access
= VEC_index (tree
, accesses
, i
);
653 access_kind base_access_now
= BINFO_ACCESS (base_binfo
);
655 if (base_access_now
== ak_none
|| base_access_now
== ak_private
)
656 /* If it was not accessible in the base, or only
657 accessible as a private member, we can't access it
659 base_access_now
= ak_none
;
660 else if (base_access
== access_protected_node
)
661 /* Public and protected members in the base become
663 base_access_now
= ak_protected
;
664 else if (base_access
== access_private_node
)
665 /* Public and protected members in the base become
667 base_access_now
= ak_private
;
669 /* See if the new access, via this base, gives more
670 access than our previous best access. */
671 if (base_access_now
!= ak_none
672 && (access
== ak_none
|| base_access_now
< access
))
674 access
= base_access_now
;
676 /* If the new access is public, we can't do better. */
677 if (access
== ak_public
)
684 /* Note the access to DECL in TYPE. */
685 SET_BINFO_ACCESS (binfo
, access
);
690 /* Return the access to DECL in TYPE. */
693 access_in_type (tree type
, tree decl
)
695 tree binfo
= TYPE_BINFO (type
);
697 /* We must take into account
701 If a name can be reached by several paths through a multiple
702 inheritance graph, the access is that of the path that gives
705 The algorithm we use is to make a post-order depth-first traversal
706 of the base-class hierarchy. As we come up the tree, we annotate
707 each node with the most lenient access. */
708 dfs_walk_once (binfo
, NULL
, dfs_access_in_type
, decl
);
710 return BINFO_ACCESS (binfo
);
713 /* Returns nonzero if it is OK to access DECL through an object
714 indicated by BINFO in the context of DERIVED. */
717 protected_accessible_p (tree decl
, tree derived
, tree binfo
)
721 /* We're checking this clause from [class.access.base]
723 m as a member of N is protected, and the reference occurs in a
724 member or friend of class N, or in a member or friend of a
725 class P derived from N, where m as a member of P is private or
728 Here DERIVED is a possible P and DECL is m. accessible_p will
729 iterate over various values of N, but the access to m in DERIVED
732 Note that I believe that the passage above is wrong, and should read
733 "...is private or protected or public"; otherwise you get bizarre results
734 whereby a public using-decl can prevent you from accessing a protected
735 member of a base. (jason 2000/02/28) */
737 /* If DERIVED isn't derived from m's class, then it can't be a P. */
738 if (!DERIVED_FROM_P (context_for_name_lookup (decl
), derived
))
741 access
= access_in_type (derived
, decl
);
743 /* If m is inaccessible in DERIVED, then it's not a P. */
744 if (access
== ak_none
)
749 When a friend or a member function of a derived class references
750 a protected nonstatic member of a base class, an access check
751 applies in addition to those described earlier in clause
752 _class.access_) Except when forming a pointer to member
753 (_expr.unary.op_), the access must be through a pointer to,
754 reference to, or object of the derived class itself (or any class
755 derived from that class) (_expr.ref_). If the access is to form
756 a pointer to member, the nested-name-specifier shall name the
757 derived class (or any class derived from that class). */
758 if (DECL_NONSTATIC_MEMBER_P (decl
))
760 /* We can tell through what the reference is occurring by
761 chasing BINFO up to the root. */
763 while (BINFO_INHERITANCE_CHAIN (t
))
764 t
= BINFO_INHERITANCE_CHAIN (t
);
766 if (!DERIVED_FROM_P (derived
, BINFO_TYPE (t
)))
773 /* Returns nonzero if SCOPE is a friend of a type which would be able
774 to access DECL through the object indicated by BINFO. */
777 friend_accessible_p (tree scope
, tree decl
, tree binfo
)
779 tree befriending_classes
;
785 if (TREE_CODE (scope
) == FUNCTION_DECL
786 || DECL_FUNCTION_TEMPLATE_P (scope
))
787 befriending_classes
= DECL_BEFRIENDING_CLASSES (scope
);
788 else if (TYPE_P (scope
))
789 befriending_classes
= CLASSTYPE_BEFRIENDING_CLASSES (scope
);
793 for (t
= befriending_classes
; t
; t
= TREE_CHAIN (t
))
794 if (protected_accessible_p (decl
, TREE_VALUE (t
), binfo
))
797 /* Nested classes are implicitly friends of their enclosing types, as
798 per core issue 45 (this is a change from the standard). */
800 for (t
= TYPE_CONTEXT (scope
); t
&& TYPE_P (t
); t
= TYPE_CONTEXT (t
))
801 if (protected_accessible_p (decl
, t
, binfo
))
804 if (TREE_CODE (scope
) == FUNCTION_DECL
805 || DECL_FUNCTION_TEMPLATE_P (scope
))
807 /* Perhaps this SCOPE is a member of a class which is a
809 if (DECL_CLASS_SCOPE_P (decl
)
810 && friend_accessible_p (DECL_CONTEXT (scope
), decl
, binfo
))
813 /* Or an instantiation of something which is a friend. */
814 if (DECL_TEMPLATE_INFO (scope
))
817 /* Increment processing_template_decl to make sure that
818 dependent_type_p works correctly. */
819 ++processing_template_decl
;
820 ret
= friend_accessible_p (DECL_TI_TEMPLATE (scope
), decl
, binfo
);
821 --processing_template_decl
;
825 else if (CLASSTYPE_TEMPLATE_INFO (scope
))
828 /* Increment processing_template_decl to make sure that
829 dependent_type_p works correctly. */
830 ++processing_template_decl
;
831 ret
= friend_accessible_p (CLASSTYPE_TI_TEMPLATE (scope
), decl
, binfo
);
832 --processing_template_decl
;
839 /* Called via dfs_walk_once_accessible from accessible_p */
842 dfs_accessible_post (tree binfo
, void *data ATTRIBUTE_UNUSED
)
844 if (BINFO_ACCESS (binfo
) != ak_none
845 && is_friend (BINFO_TYPE (binfo
), current_scope ()))
851 /* DECL is a declaration from a base class of TYPE, which was the
852 class used to name DECL. Return nonzero if, in the current
853 context, DECL is accessible. If TYPE is actually a BINFO node,
854 then we can tell in what context the access is occurring by looking
855 at the most derived class along the path indicated by BINFO. */
858 accessible_p (tree type
, tree decl
)
865 /* Nonzero if it's OK to access DECL if it has protected
866 accessibility in TYPE. */
867 int protected_ok
= 0;
869 /* If this declaration is in a block or namespace scope, there's no
871 if (!TYPE_P (context_for_name_lookup (decl
)))
874 /* There is no need to perform access checks inside a thunk. */
875 scope
= current_scope ();
876 if (scope
&& DECL_THUNK_P (scope
))
879 /* In a template declaration, we cannot be sure whether the
880 particular specialization that is instantiated will be a friend
881 or not. Therefore, all access checks are deferred until
883 if (processing_template_decl
)
889 type
= BINFO_TYPE (type
);
892 binfo
= TYPE_BINFO (type
);
894 /* [class.access.base]
896 A member m is accessible when named in class N if
898 --m as a member of N is public, or
900 --m as a member of N is private, and the reference occurs in a
901 member or friend of class N, or
903 --m as a member of N is protected, and the reference occurs in a
904 member or friend of class N, or in a member or friend of a
905 class P derived from N, where m as a member of P is private or
908 --there exists a base class B of N that is accessible at the point
909 of reference, and m is accessible when named in class B.
911 We walk the base class hierarchy, checking these conditions. */
913 /* Figure out where the reference is occurring. Check to see if
914 DECL is private or protected in this scope, since that will
915 determine whether protected access is allowed. */
916 if (current_class_type
)
917 protected_ok
= protected_accessible_p (decl
, current_class_type
, binfo
);
919 /* Now, loop through the classes of which we are a friend. */
921 protected_ok
= friend_accessible_p (scope
, decl
, binfo
);
923 /* Standardize the binfo that access_in_type will use. We don't
924 need to know what path was chosen from this point onwards. */
925 binfo
= TYPE_BINFO (type
);
927 /* Compute the accessibility of DECL in the class hierarchy
928 dominated by type. */
929 access
= access_in_type (type
, decl
);
930 if (access
== ak_public
931 || (access
== ak_protected
&& protected_ok
))
935 /* Walk the hierarchy again, looking for a base class that allows
937 t
= dfs_walk_once_accessible (binfo
, /*friends=*/true,
938 NULL
, dfs_accessible_post
, NULL
);
940 return t
!= NULL_TREE
;
944 struct lookup_field_info
{
945 /* The type in which we're looking. */
947 /* The name of the field for which we're looking. */
949 /* If non-NULL, the current result of the lookup. */
951 /* The path to RVAL. */
953 /* If non-NULL, the lookup was ambiguous, and this is a list of the
956 /* If nonzero, we are looking for types, not data members. */
958 /* If something went wrong, a message indicating what. */
962 /* Within the scope of a template class, you can refer to the to the
963 current specialization with the name of the template itself. For
966 template <typename T> struct S { S* sp; }
968 Returns nonzero if DECL is such a declaration in a class TYPE. */
971 template_self_reference_p (tree type
, tree decl
)
973 return (CLASSTYPE_USE_TEMPLATE (type
)
974 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
))
975 && TREE_CODE (decl
) == TYPE_DECL
976 && DECL_ARTIFICIAL (decl
)
977 && DECL_NAME (decl
) == constructor_name (type
));
980 /* Nonzero for a class member means that it is shared between all objects
983 [class.member.lookup]:If the resulting set of declarations are not all
984 from sub-objects of the same type, or the set has a nonstatic member
985 and includes members from distinct sub-objects, there is an ambiguity
986 and the program is ill-formed.
988 This function checks that T contains no nonstatic members. */
991 shared_member_p (tree t
)
993 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == TYPE_DECL \
994 || TREE_CODE (t
) == CONST_DECL
)
996 if (is_overloaded_fn (t
))
998 for (; t
; t
= OVL_NEXT (t
))
1000 tree fn
= OVL_CURRENT (t
);
1001 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1009 /* Routine to see if the sub-object denoted by the binfo PARENT can be
1010 found as a base class and sub-object of the object denoted by
1014 is_subobject_of_p (tree parent
, tree binfo
)
1018 for (probe
= parent
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
1022 if (BINFO_VIRTUAL_P (probe
))
1023 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (binfo
))
1029 /* DATA is really a struct lookup_field_info. Look for a field with
1030 the name indicated there in BINFO. If this function returns a
1031 non-NULL value it is the result of the lookup. Called from
1032 lookup_field via breadth_first_search. */
1035 lookup_field_r (tree binfo
, void *data
)
1037 struct lookup_field_info
*lfi
= (struct lookup_field_info
*) data
;
1038 tree type
= BINFO_TYPE (binfo
);
1039 tree nval
= NULL_TREE
;
1041 /* If this is a dependent base, don't look in it. */
1042 if (BINFO_DEPENDENT_BASE_P (binfo
))
1045 /* If this base class is hidden by the best-known value so far, we
1046 don't need to look. */
1047 if (lfi
->rval_binfo
&& BINFO_INHERITANCE_CHAIN (binfo
) == lfi
->rval_binfo
1048 && !BINFO_VIRTUAL_P (binfo
))
1049 return dfs_skip_bases
;
1051 /* First, look for a function. There can't be a function and a data
1052 member with the same name, and if there's a function and a type
1053 with the same name, the type is hidden by the function. */
1054 if (!lfi
->want_type
)
1056 int idx
= lookup_fnfields_1 (type
, lfi
->name
);
1058 nval
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), idx
);
1062 /* Look for a data member or type. */
1063 nval
= lookup_field_1 (type
, lfi
->name
, lfi
->want_type
);
1065 /* If there is no declaration with the indicated name in this type,
1066 then there's nothing to do. */
1070 /* If we're looking up a type (as with an elaborated type specifier)
1071 we ignore all non-types we find. */
1072 if (lfi
->want_type
&& TREE_CODE (nval
) != TYPE_DECL
1073 && !DECL_CLASS_TEMPLATE_P (nval
))
1075 if (lfi
->name
== TYPE_IDENTIFIER (type
))
1077 /* If the aggregate has no user defined constructors, we allow
1078 it to have fields with the same name as the enclosing type.
1079 If we are looking for that name, find the corresponding
1081 for (nval
= TREE_CHAIN (nval
); nval
; nval
= TREE_CHAIN (nval
))
1082 if (DECL_NAME (nval
) == lfi
->name
1083 && TREE_CODE (nval
) == TYPE_DECL
)
1088 if (!nval
&& CLASSTYPE_NESTED_UTDS (type
) != NULL
)
1090 binding_entry e
= binding_table_find (CLASSTYPE_NESTED_UTDS (type
),
1093 nval
= TYPE_MAIN_DECL (e
->type
);
1099 /* You must name a template base class with a template-id. */
1100 if (!same_type_p (type
, lfi
->type
)
1101 && template_self_reference_p (type
, nval
))
1104 /* If the lookup already found a match, and the new value doesn't
1105 hide the old one, we might have an ambiguity. */
1107 && !is_subobject_of_p (lfi
->rval_binfo
, binfo
))
1110 if (nval
== lfi
->rval
&& shared_member_p (nval
))
1111 /* The two things are really the same. */
1113 else if (is_subobject_of_p (binfo
, lfi
->rval_binfo
))
1114 /* The previous value hides the new one. */
1118 /* We have a real ambiguity. We keep a chain of all the
1120 if (!lfi
->ambiguous
&& lfi
->rval
)
1122 /* This is the first time we noticed an ambiguity. Add
1123 what we previously thought was a reasonable candidate
1125 lfi
->ambiguous
= tree_cons (NULL_TREE
, lfi
->rval
, NULL_TREE
);
1126 TREE_TYPE (lfi
->ambiguous
) = error_mark_node
;
1129 /* Add the new value. */
1130 lfi
->ambiguous
= tree_cons (NULL_TREE
, nval
, lfi
->ambiguous
);
1131 TREE_TYPE (lfi
->ambiguous
) = error_mark_node
;
1132 lfi
->errstr
= "request for member `%D' is ambiguous";
1138 lfi
->rval_binfo
= binfo
;
1142 /* Don't look for constructors or destructors in base classes. */
1143 if (IDENTIFIER_CTOR_OR_DTOR_P (lfi
->name
))
1144 return dfs_skip_bases
;
1148 /* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO,
1149 BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO,
1150 FUNCTIONS, and OPTYPE respectively. */
1153 build_baselink (tree binfo
, tree access_binfo
, tree functions
, tree optype
)
1157 gcc_assert (TREE_CODE (functions
) == FUNCTION_DECL
1158 || TREE_CODE (functions
) == TEMPLATE_DECL
1159 || TREE_CODE (functions
) == TEMPLATE_ID_EXPR
1160 || TREE_CODE (functions
) == OVERLOAD
);
1161 gcc_assert (!optype
|| TYPE_P (optype
));
1162 gcc_assert (TREE_TYPE (functions
));
1164 baselink
= make_node (BASELINK
);
1165 TREE_TYPE (baselink
) = TREE_TYPE (functions
);
1166 BASELINK_BINFO (baselink
) = binfo
;
1167 BASELINK_ACCESS_BINFO (baselink
) = access_binfo
;
1168 BASELINK_FUNCTIONS (baselink
) = functions
;
1169 BASELINK_OPTYPE (baselink
) = optype
;
1174 /* Look for a member named NAME in an inheritance lattice dominated by
1175 XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
1176 is 1, we enforce accessibility. If PROTECT is zero, then, for an
1177 ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
1178 messages about inaccessible or ambiguous lookup. If PROTECT is 2,
1179 we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
1180 TREE_VALUEs are the list of ambiguous candidates.
1182 WANT_TYPE is 1 when we should only return TYPE_DECLs.
1184 If nothing can be found return NULL_TREE and do not issue an error. */
1187 lookup_member (tree xbasetype
, tree name
, int protect
, bool want_type
)
1189 tree rval
, rval_binfo
= NULL_TREE
;
1190 tree type
= NULL_TREE
, basetype_path
= NULL_TREE
;
1191 struct lookup_field_info lfi
;
1193 /* rval_binfo is the binfo associated with the found member, note,
1194 this can be set with useful information, even when rval is not
1195 set, because it must deal with ALL members, not just non-function
1196 members. It is used for ambiguity checking and the hidden
1197 checks. Whereas rval is only set if a proper (not hidden)
1198 non-function member is found. */
1200 const char *errstr
= 0;
1202 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1204 if (TREE_CODE (xbasetype
) == TREE_BINFO
)
1206 type
= BINFO_TYPE (xbasetype
);
1207 basetype_path
= xbasetype
;
1211 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (xbasetype
)));
1213 xbasetype
= NULL_TREE
;
1216 type
= complete_type (type
);
1218 basetype_path
= TYPE_BINFO (type
);
1223 #ifdef GATHER_STATISTICS
1224 n_calls_lookup_field
++;
1225 #endif /* GATHER_STATISTICS */
1227 memset (&lfi
, 0, sizeof (lfi
));
1230 lfi
.want_type
= want_type
;
1231 dfs_walk_all (basetype_path
, &lookup_field_r
, NULL
, &lfi
);
1233 rval_binfo
= lfi
.rval_binfo
;
1235 type
= BINFO_TYPE (rval_binfo
);
1236 errstr
= lfi
.errstr
;
1238 /* If we are not interested in ambiguities, don't report them;
1239 just return NULL_TREE. */
1240 if (!protect
&& lfi
.ambiguous
)
1246 return lfi
.ambiguous
;
1253 In the case of overloaded function names, access control is
1254 applied to the function selected by overloaded resolution. */
1255 if (rval
&& protect
&& !is_overloaded_fn (rval
))
1256 perform_or_defer_access_check (basetype_path
, rval
);
1258 if (errstr
&& protect
)
1260 error (errstr
, name
, type
);
1262 print_candidates (lfi
.ambiguous
);
1263 rval
= error_mark_node
;
1266 if (rval
&& is_overloaded_fn (rval
))
1267 rval
= build_baselink (rval_binfo
, basetype_path
, rval
,
1268 (IDENTIFIER_TYPENAME_P (name
)
1269 ? TREE_TYPE (name
): NULL_TREE
));
1273 /* Like lookup_member, except that if we find a function member we
1274 return NULL_TREE. */
1277 lookup_field (tree xbasetype
, tree name
, int protect
, bool want_type
)
1279 tree rval
= lookup_member (xbasetype
, name
, protect
, want_type
);
1281 /* Ignore functions, but propagate the ambiguity list. */
1282 if (!error_operand_p (rval
)
1283 && (rval
&& BASELINK_P (rval
)))
1289 /* Like lookup_member, except that if we find a non-function member we
1290 return NULL_TREE. */
1293 lookup_fnfields (tree xbasetype
, tree name
, int protect
)
1295 tree rval
= lookup_member (xbasetype
, name
, protect
, /*want_type=*/false);
1297 /* Ignore non-functions, but propagate the ambiguity list. */
1298 if (!error_operand_p (rval
)
1299 && (rval
&& !BASELINK_P (rval
)))
1305 /* Return the index in the CLASSTYPE_METHOD_VEC for CLASS_TYPE
1306 corresponding to "operator TYPE ()", or -1 if there is no such
1307 operator. Only CLASS_TYPE itself is searched; this routine does
1308 not scan the base classes of CLASS_TYPE. */
1311 lookup_conversion_operator (tree class_type
, tree type
)
1315 if (TYPE_HAS_CONVERSION (class_type
))
1319 VEC(tree
) *methods
= CLASSTYPE_METHOD_VEC (class_type
);
1321 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1322 VEC_iterate (tree
, methods
, i
, fn
); ++i
)
1324 /* All the conversion operators come near the beginning of
1325 the class. Therefore, if FN is not a conversion
1326 operator, there is no matching conversion operator in
1328 fn
= OVL_CURRENT (fn
);
1329 if (!DECL_CONV_FN_P (fn
))
1332 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1333 /* All the templated conversion functions are on the same
1334 slot, so remember it. */
1336 else if (same_type_p (DECL_CONV_FN_TYPE (fn
), type
))
1344 /* TYPE is a class type. Return the index of the fields within
1345 the method vector with name NAME, or -1 is no such field exists. */
1348 lookup_fnfields_1 (tree type
, tree name
)
1350 VEC(tree
) *method_vec
;
1355 if (!CLASS_TYPE_P (type
))
1358 if (COMPLETE_TYPE_P (type
))
1360 if ((name
== ctor_identifier
1361 || name
== base_ctor_identifier
1362 || name
== complete_ctor_identifier
))
1364 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type
))
1365 lazily_declare_fn (sfk_constructor
, type
);
1366 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
1367 lazily_declare_fn (sfk_copy_constructor
, type
);
1369 else if (name
== ansi_assopname(NOP_EXPR
)
1370 && CLASSTYPE_LAZY_ASSIGNMENT_OP (type
))
1371 lazily_declare_fn (sfk_assignment_operator
, type
);
1374 method_vec
= CLASSTYPE_METHOD_VEC (type
);
1378 #ifdef GATHER_STATISTICS
1379 n_calls_lookup_fnfields_1
++;
1380 #endif /* GATHER_STATISTICS */
1382 /* Constructors are first... */
1383 if (name
== ctor_identifier
)
1385 fn
= CLASSTYPE_CONSTRUCTORS (type
);
1386 return fn
? CLASSTYPE_CONSTRUCTOR_SLOT
: -1;
1388 /* and destructors are second. */
1389 if (name
== dtor_identifier
)
1391 fn
= CLASSTYPE_DESTRUCTORS (type
);
1392 return fn
? CLASSTYPE_DESTRUCTOR_SLOT
: -1;
1394 if (IDENTIFIER_TYPENAME_P (name
))
1395 return lookup_conversion_operator (type
, TREE_TYPE (name
));
1397 /* Skip the conversion operators. */
1398 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1399 VEC_iterate (tree
, method_vec
, i
, fn
);
1401 if (!DECL_CONV_FN_P (OVL_CURRENT (fn
)))
1404 /* If the type is complete, use binary search. */
1405 if (COMPLETE_TYPE_P (type
))
1411 hi
= VEC_length (tree
, method_vec
);
1416 #ifdef GATHER_STATISTICS
1417 n_outer_fields_searched
++;
1418 #endif /* GATHER_STATISTICS */
1420 tmp
= VEC_index (tree
, method_vec
, i
);
1421 tmp
= DECL_NAME (OVL_CURRENT (tmp
));
1424 else if (tmp
< name
)
1431 for (; VEC_iterate (tree
, method_vec
, i
, fn
); ++i
)
1433 #ifdef GATHER_STATISTICS
1434 n_outer_fields_searched
++;
1435 #endif /* GATHER_STATISTICS */
1436 if (DECL_NAME (OVL_CURRENT (fn
)) == name
)
1443 /* Like lookup_fnfields_1, except that the name is extracted from
1444 FUNCTION, which is a FUNCTION_DECL or a TEMPLATE_DECL. */
1447 class_method_index_for_fn (tree class_type
, tree function
)
1449 gcc_assert (TREE_CODE (function
) == FUNCTION_DECL
1450 || DECL_FUNCTION_TEMPLATE_P (function
));
1452 return lookup_fnfields_1 (class_type
,
1453 DECL_CONSTRUCTOR_P (function
) ? ctor_identifier
:
1454 DECL_DESTRUCTOR_P (function
) ? dtor_identifier
:
1455 DECL_NAME (function
));
1459 /* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
1460 the class or namespace used to qualify the name. CONTEXT_CLASS is
1461 the class corresponding to the object in which DECL will be used.
1462 Return a possibly modified version of DECL that takes into account
1465 In particular, consider an expression like `B::m' in the context of
1466 a derived class `D'. If `B::m' has been resolved to a BASELINK,
1467 then the most derived class indicated by the BASELINK_BINFO will be
1468 `B', not `D'. This function makes that adjustment. */
1471 adjust_result_of_qualified_name_lookup (tree decl
,
1472 tree qualifying_scope
,
1475 if (context_class
&& CLASS_TYPE_P (qualifying_scope
)
1476 && DERIVED_FROM_P (qualifying_scope
, context_class
)
1477 && BASELINK_P (decl
))
1481 gcc_assert (CLASS_TYPE_P (context_class
));
1483 /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
1484 Because we do not yet know which function will be chosen by
1485 overload resolution, we cannot yet check either accessibility
1486 or ambiguity -- in either case, the choice of a static member
1487 function might make the usage valid. */
1488 base
= lookup_base (context_class
, qualifying_scope
,
1489 ba_ignore
| ba_quiet
, NULL
);
1492 BASELINK_ACCESS_BINFO (decl
) = base
;
1493 BASELINK_BINFO (decl
)
1494 = lookup_base (base
, BINFO_TYPE (BASELINK_BINFO (decl
)),
1495 ba_ignore
| ba_quiet
,
1504 /* Walk the class hierarchy within BINFO, in a depth-first traversal.
1505 PRE_FN is called in preorder, while POST_FN is called in postorder.
1506 If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
1507 walked. If PRE_FN or POST_FN returns a different non-NULL value,
1508 that value is immediately returned and the walk is terminated. One
1509 of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
1510 POST_FN are passed the binfo to examine and the caller's DATA
1511 value. All paths are walked, thus virtual and morally virtual
1512 binfos can be multiply walked. */
1515 dfs_walk_all (tree binfo
, tree (*pre_fn
) (tree
, void *),
1516 tree (*post_fn
) (tree
, void *), void *data
)
1522 /* Call the pre-order walking function. */
1525 rval
= pre_fn (binfo
, data
);
1528 if (rval
== dfs_skip_bases
)
1534 /* Find the next child binfo to walk. */
1535 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1537 rval
= dfs_walk_all (base_binfo
, pre_fn
, post_fn
, data
);
1543 /* Call the post-order walking function. */
1545 return post_fn (binfo
, data
);
1549 /* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1550 that binfos are walked at most once. */
1553 dfs_walk_once_r (tree binfo
, tree (*pre_fn
) (tree
, void *),
1554 tree (*post_fn
) (tree
, void *), void *data
)
1560 /* Call the pre-order walking function. */
1563 rval
= pre_fn (binfo
, data
);
1566 if (rval
== dfs_skip_bases
)
1573 /* Find the next child binfo to walk. */
1574 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1576 if (BINFO_VIRTUAL_P (base_binfo
))
1578 if (BINFO_MARKED (base_binfo
))
1580 BINFO_MARKED (base_binfo
) = 1;
1583 rval
= dfs_walk_once_r (base_binfo
, pre_fn
, post_fn
, data
);
1589 /* Call the post-order walking function. */
1591 return post_fn (binfo
, data
);
1596 /* Worker for dfs_walk_once. Recursively unmark the virtual base binfos of
1600 dfs_unmark_r (tree binfo
)
1605 /* Process the basetypes. */
1606 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1608 if (BINFO_VIRTUAL_P (base_binfo
))
1610 if (!BINFO_MARKED (base_binfo
))
1612 BINFO_MARKED (base_binfo
) = 0;
1614 /* Only walk, if it can contain more virtual bases. */
1615 if (CLASSTYPE_VBASECLASSES (BINFO_TYPE (base_binfo
)))
1616 dfs_unmark_r (base_binfo
);
1620 /* Like dfs_walk_all, except that binfos are not multiply walked. For
1621 non-diamond shaped hierarchies this is the same as dfs_walk_all.
1622 For diamond shaped hierarchies we must mark the virtual bases, to
1623 avoid multiple walks. */
1626 dfs_walk_once (tree binfo
, tree (*pre_fn
) (tree
, void *),
1627 tree (*post_fn
) (tree
, void *), void *data
)
1631 gcc_assert (pre_fn
|| post_fn
);
1633 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
)))
1634 /* We are not diamond shaped, and therefore cannot encounter the
1635 same binfo twice. */
1636 rval
= dfs_walk_all (binfo
, pre_fn
, post_fn
, data
);
1639 rval
= dfs_walk_once_r (binfo
, pre_fn
, post_fn
, data
);
1640 if (!BINFO_INHERITANCE_CHAIN (binfo
))
1642 /* We are at the top of the hierarchy, and can use the
1643 CLASSTYPE_VBASECLASSES list for unmarking the virtual
1649 for (vbases
= CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)), ix
= 0;
1650 VEC_iterate (tree
, vbases
, ix
, base_binfo
); ix
++)
1651 BINFO_MARKED (base_binfo
) = 0;
1654 dfs_unmark_r (binfo
);
1659 /* Worker function for dfs_walk_once_accessible. Behaves like
1660 dfs_walk_once_r, except (a) FRIENDS_P is true if special
1661 access given by the current context should be considered, (b) ONCE
1662 indicates whether bases should be marked during traversal. */
1665 dfs_walk_once_accessible_r (tree binfo
, bool friends_p
, bool once
,
1666 tree (*pre_fn
) (tree
, void *),
1667 tree (*post_fn
) (tree
, void *), void *data
)
1669 tree rval
= NULL_TREE
;
1673 /* Call the pre-order walking function. */
1676 rval
= pre_fn (binfo
, data
);
1679 if (rval
== dfs_skip_bases
)
1686 /* Find the next child binfo to walk. */
1687 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1689 bool mark
= once
&& BINFO_VIRTUAL_P (base_binfo
);
1691 if (mark
&& BINFO_MARKED (base_binfo
))
1694 /* If the base is inherited via private or protected
1695 inheritance, then we can't see it, unless we are a friend of
1696 the current binfo. */
1697 if (BINFO_BASE_ACCESS (binfo
, ix
) != access_public_node
1698 && !(friends_p
&& is_friend (BINFO_TYPE (binfo
), current_scope ())))
1702 BINFO_MARKED (base_binfo
) = 1;
1704 rval
= dfs_walk_once_accessible_r (base_binfo
, friends_p
, once
,
1705 pre_fn
, post_fn
, data
);
1711 /* Call the post-order walking function. */
1713 return post_fn (binfo
, data
);
1718 /* Like dfs_walk_once except that only accessible bases are walked.
1719 FRIENDS_P indicates whether friendship of the local context
1720 should be considered when determining accessibility. */
1723 dfs_walk_once_accessible (tree binfo
, bool friends_p
,
1724 tree (*pre_fn
) (tree
, void *),
1725 tree (*post_fn
) (tree
, void *), void *data
)
1727 bool diamond_shaped
= CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
));
1728 tree rval
= dfs_walk_once_accessible_r (binfo
, friends_p
, diamond_shaped
,
1729 pre_fn
, post_fn
, data
);
1733 if (!BINFO_INHERITANCE_CHAIN (binfo
))
1735 /* We are at the top of the hierarchy, and can use the
1736 CLASSTYPE_VBASECLASSES list for unmarking the virtual
1742 for (vbases
= CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)), ix
= 0;
1743 VEC_iterate (tree
, vbases
, ix
, base_binfo
); ix
++)
1744 BINFO_MARKED (base_binfo
) = 0;
1747 dfs_unmark_r (binfo
);
1752 /* Check that virtual overrider OVERRIDER is acceptable for base function
1753 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
1756 check_final_overrider (tree overrider
, tree basefn
)
1758 tree over_type
= TREE_TYPE (overrider
);
1759 tree base_type
= TREE_TYPE (basefn
);
1760 tree over_return
= TREE_TYPE (over_type
);
1761 tree base_return
= TREE_TYPE (base_type
);
1762 tree over_throw
= TYPE_RAISES_EXCEPTIONS (over_type
);
1763 tree base_throw
= TYPE_RAISES_EXCEPTIONS (base_type
);
1766 if (DECL_INVALID_OVERRIDER_P (overrider
))
1769 if (same_type_p (base_return
, over_return
))
1771 else if ((CLASS_TYPE_P (over_return
) && CLASS_TYPE_P (base_return
))
1772 || (TREE_CODE (base_return
) == TREE_CODE (over_return
)
1773 && POINTER_TYPE_P (base_return
)))
1775 /* Potentially covariant. */
1776 unsigned base_quals
, over_quals
;
1778 fail
= !POINTER_TYPE_P (base_return
);
1781 fail
= cp_type_quals (base_return
) != cp_type_quals (over_return
);
1783 base_return
= TREE_TYPE (base_return
);
1784 over_return
= TREE_TYPE (over_return
);
1786 base_quals
= cp_type_quals (base_return
);
1787 over_quals
= cp_type_quals (over_return
);
1789 if ((base_quals
& over_quals
) != over_quals
)
1792 if (CLASS_TYPE_P (base_return
) && CLASS_TYPE_P (over_return
))
1794 tree binfo
= lookup_base (over_return
, base_return
,
1795 ba_check
| ba_quiet
, NULL
);
1801 && can_convert (TREE_TYPE (base_type
), TREE_TYPE (over_type
)))
1802 /* GNU extension, allow trivial pointer conversions such as
1803 converting to void *, or qualification conversion. */
1805 /* can_convert will permit user defined conversion from a
1806 (reference to) class type. We must reject them. */
1807 over_return
= non_reference (TREE_TYPE (over_type
));
1808 if (CLASS_TYPE_P (over_return
))
1822 cp_error_at ("invalid covariant return type for %q#D", overrider
);
1823 cp_error_at (" overriding %q#D", basefn
);
1827 cp_error_at ("conflicting return type specified for %q#D",
1829 cp_error_at (" overriding %q#D", basefn
);
1831 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
1835 /* Check throw specifier is at least as strict. */
1836 if (!comp_except_specs (base_throw
, over_throw
, 0))
1838 cp_error_at ("looser throw specifier for %q#F", overrider
);
1839 cp_error_at (" overriding %q#F", basefn
);
1840 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
1847 /* Given a class TYPE, and a function decl FNDECL, look for
1848 virtual functions in TYPE's hierarchy which FNDECL overrides.
1849 We do not look in TYPE itself, only its bases.
1851 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
1852 find that it overrides anything.
1854 We check that every function which is overridden, is correctly
1858 look_for_overrides (tree type
, tree fndecl
)
1860 tree binfo
= TYPE_BINFO (type
);
1865 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1867 tree basetype
= BINFO_TYPE (base_binfo
);
1869 if (TYPE_POLYMORPHIC_P (basetype
))
1870 found
+= look_for_overrides_r (basetype
, fndecl
);
1875 /* Look in TYPE for virtual functions with the same signature as
1879 look_for_overrides_here (tree type
, tree fndecl
)
1883 /* If there are no methods in TYPE (meaning that only implicitly
1884 declared methods will ever be provided for TYPE), then there are
1885 no virtual functions. */
1886 if (!CLASSTYPE_METHOD_VEC (type
))
1889 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fndecl
))
1890 ix
= CLASSTYPE_DESTRUCTOR_SLOT
;
1892 ix
= lookup_fnfields_1 (type
, DECL_NAME (fndecl
));
1895 tree fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
1897 for (; fns
; fns
= OVL_NEXT (fns
))
1899 tree fn
= OVL_CURRENT (fns
);
1901 if (!DECL_VIRTUAL_P (fn
))
1902 /* Not a virtual. */;
1903 else if (DECL_CONTEXT (fn
) != type
)
1904 /* Introduced with a using declaration. */;
1905 else if (DECL_STATIC_FUNCTION_P (fndecl
))
1907 tree btypes
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1908 tree dtypes
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
1909 if (compparms (TREE_CHAIN (btypes
), dtypes
))
1912 else if (same_signature_p (fndecl
, fn
))
1919 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
1920 TYPE itself and its bases. */
1923 look_for_overrides_r (tree type
, tree fndecl
)
1925 tree fn
= look_for_overrides_here (type
, fndecl
);
1928 if (DECL_STATIC_FUNCTION_P (fndecl
))
1930 /* A static member function cannot match an inherited
1931 virtual member function. */
1932 cp_error_at ("%q#D cannot be declared", fndecl
);
1933 cp_error_at (" since %q#D declared in base class", fn
);
1937 /* It's definitely virtual, even if not explicitly set. */
1938 DECL_VIRTUAL_P (fndecl
) = 1;
1939 check_final_overrider (fndecl
, fn
);
1944 /* We failed to find one declared in this class. Look in its bases. */
1945 return look_for_overrides (type
, fndecl
);
1948 /* Called via dfs_walk from dfs_get_pure_virtuals. */
1951 dfs_get_pure_virtuals (tree binfo
, void *data
)
1953 tree type
= (tree
) data
;
1955 /* We're not interested in primary base classes; the derived class
1956 of which they are a primary base will contain the information we
1958 if (!BINFO_PRIMARY_P (binfo
))
1962 for (virtuals
= BINFO_VIRTUALS (binfo
);
1964 virtuals
= TREE_CHAIN (virtuals
))
1965 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals
)))
1966 VEC_safe_push (tree
, CLASSTYPE_PURE_VIRTUALS (type
),
1973 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
1976 get_pure_virtuals (tree type
)
1978 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
1979 is going to be overridden. */
1980 CLASSTYPE_PURE_VIRTUALS (type
) = NULL
;
1981 /* Now, run through all the bases which are not primary bases, and
1982 collect the pure virtual functions. We look at the vtable in
1983 each class to determine what pure virtual functions are present.
1984 (A primary base is not interesting because the derived class of
1985 which it is a primary base will contain vtable entries for the
1986 pure virtuals in the base class. */
1987 dfs_walk_once (TYPE_BINFO (type
), NULL
, dfs_get_pure_virtuals
, type
);
1990 /* Debug info for C++ classes can get very large; try to avoid
1991 emitting it everywhere.
1993 Note that this optimization wins even when the target supports
1994 BINCL (if only slightly), and reduces the amount of work for the
1998 maybe_suppress_debug_info (tree t
)
2000 if (write_symbols
== NO_DEBUG
)
2003 /* We might have set this earlier in cp_finish_decl. */
2004 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 0;
2006 /* If we already know how we're handling this class, handle debug info
2008 if (CLASSTYPE_INTERFACE_KNOWN (t
))
2010 if (CLASSTYPE_INTERFACE_ONLY (t
))
2011 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2012 /* else don't set it. */
2014 /* If the class has a vtable, write out the debug info along with
2016 else if (TYPE_CONTAINS_VPTR_P (t
))
2017 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2019 /* Otherwise, just emit the debug info normally. */
2022 /* Note that we want debugging information for a base class of a class
2023 whose vtable is being emitted. Normally, this would happen because
2024 calling the constructor for a derived class implies calling the
2025 constructors for all bases, which involve initializing the
2026 appropriate vptr with the vtable for the base class; but in the
2027 presence of optimization, this initialization may be optimized
2028 away, so we tell finish_vtable_vardecl that we want the debugging
2029 information anyway. */
2032 dfs_debug_mark (tree binfo
, void *data ATTRIBUTE_UNUSED
)
2034 tree t
= BINFO_TYPE (binfo
);
2036 if (CLASSTYPE_DEBUG_REQUESTED (t
))
2037 return dfs_skip_bases
;
2039 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
2044 /* Write out the debugging information for TYPE, whose vtable is being
2045 emitted. Also walk through our bases and note that we want to
2046 write out information for them. This avoids the problem of not
2047 writing any debug info for intermediate basetypes whose
2048 constructors, and thus the references to their vtables, and thus
2049 the vtables themselves, were optimized away. */
2052 note_debug_info_needed (tree type
)
2054 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
2056 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)) = 0;
2057 rest_of_type_compilation (type
, toplevel_bindings_p ());
2060 dfs_walk_all (TYPE_BINFO (type
), dfs_debug_mark
, NULL
, 0);
2064 print_search_statistics (void)
2066 #ifdef GATHER_STATISTICS
2067 fprintf (stderr
, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
2068 n_fields_searched
, n_calls_lookup_field
, n_calls_lookup_field_1
);
2069 fprintf (stderr
, "%d fnfields searched in %d calls to lookup_fnfields\n",
2070 n_outer_fields_searched
, n_calls_lookup_fnfields
);
2071 fprintf (stderr
, "%d calls to get_base_type\n", n_calls_get_base_type
);
2072 #else /* GATHER_STATISTICS */
2073 fprintf (stderr
, "no search statistics\n");
2074 #endif /* GATHER_STATISTICS */
2078 reinit_search_statistics (void)
2080 #ifdef GATHER_STATISTICS
2081 n_fields_searched
= 0;
2082 n_calls_lookup_field
= 0, n_calls_lookup_field_1
= 0;
2083 n_calls_lookup_fnfields
= 0, n_calls_lookup_fnfields_1
= 0;
2084 n_calls_get_base_type
= 0;
2085 n_outer_fields_searched
= 0;
2086 n_contexts_saved
= 0;
2087 #endif /* GATHER_STATISTICS */
2090 /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2091 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2092 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2093 bases have been encountered already in the tree walk. PARENT_CONVS
2094 is the list of lists of conversion functions that could hide CONV
2095 and OTHER_CONVS is the list of lists of conversion functions that
2096 could hide or be hidden by CONV, should virtualness be involved in
2097 the hierarchy. Merely checking the conversion op's name is not
2098 enough because two conversion operators to the same type can have
2099 different names. Return nonzero if we are visible. */
2102 check_hidden_convs (tree binfo
, int virtual_depth
, int virtualness
,
2103 tree to_type
, tree parent_convs
, tree other_convs
)
2107 /* See if we are hidden by a parent conversion. */
2108 for (level
= parent_convs
; level
; level
= TREE_CHAIN (level
))
2109 for (probe
= TREE_VALUE (level
); probe
; probe
= TREE_CHAIN (probe
))
2110 if (same_type_p (to_type
, TREE_TYPE (probe
)))
2113 if (virtual_depth
|| virtualness
)
2115 /* In a virtual hierarchy, we could be hidden, or could hide a
2116 conversion function on the other_convs list. */
2117 for (level
= other_convs
; level
; level
= TREE_CHAIN (level
))
2123 if (!(virtual_depth
|| TREE_STATIC (level
)))
2124 /* Neither is morally virtual, so cannot hide each other. */
2127 if (!TREE_VALUE (level
))
2128 /* They evaporated away already. */
2131 they_hide_us
= (virtual_depth
2132 && original_binfo (binfo
, TREE_PURPOSE (level
)));
2133 we_hide_them
= (!they_hide_us
&& TREE_STATIC (level
)
2134 && original_binfo (TREE_PURPOSE (level
), binfo
));
2136 if (!(we_hide_them
|| they_hide_us
))
2137 /* Neither is within the other, so no hiding can occur. */
2140 for (prev
= &TREE_VALUE (level
), other
= *prev
; other
;)
2142 if (same_type_p (to_type
, TREE_TYPE (other
)))
2145 /* We are hidden. */
2150 /* We hide the other one. */
2151 other
= TREE_CHAIN (other
);
2156 prev
= &TREE_CHAIN (other
);
2164 /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2165 of conversion functions, the first slot will be for the current
2166 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2167 of conversion functions from children of the current binfo,
2168 concatenated with conversions from elsewhere in the hierarchy --
2169 that list begins with OTHER_CONVS. Return a single list of lists
2170 containing only conversions from the current binfo and its
2174 split_conversions (tree my_convs
, tree parent_convs
,
2175 tree child_convs
, tree other_convs
)
2180 /* Remove the original other_convs portion from child_convs. */
2181 for (prev
= NULL
, t
= child_convs
;
2182 t
!= other_convs
; prev
= t
, t
= TREE_CHAIN (t
))
2186 TREE_CHAIN (prev
) = NULL_TREE
;
2188 child_convs
= NULL_TREE
;
2190 /* Attach the child convs to any we had at this level. */
2193 my_convs
= parent_convs
;
2194 TREE_CHAIN (my_convs
) = child_convs
;
2197 my_convs
= child_convs
;
2202 /* Worker for lookup_conversions. Lookup conversion functions in
2203 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in
2204 a morally virtual base, and VIRTUALNESS is nonzero, if we've
2205 encountered virtual bases already in the tree walk. PARENT_CONVS &
2206 PARENT_TPL_CONVS are lists of list of conversions within parent
2207 binfos. OTHER_CONVS and OTHER_TPL_CONVS are conversions found
2208 elsewhere in the tree. Return the conversions found within this
2209 portion of the graph in CONVS and TPL_CONVS. Return nonzero is we
2210 encountered virtualness. We keep template and non-template
2211 conversions separate, to avoid unnecessary type comparisons.
2213 The located conversion functions are held in lists of lists. The
2214 TREE_VALUE of the outer list is the list of conversion functions
2215 found in a particular binfo. The TREE_PURPOSE of both the outer
2216 and inner lists is the binfo at which those conversions were
2217 found. TREE_STATIC is set for those lists within of morally
2218 virtual binfos. The TREE_VALUE of the inner list is the conversion
2219 function or overload itself. The TREE_TYPE of each inner list node
2220 is the converted-to type. */
2223 lookup_conversions_r (tree binfo
,
2224 int virtual_depth
, int virtualness
,
2225 tree parent_convs
, tree parent_tpl_convs
,
2226 tree other_convs
, tree other_tpl_convs
,
2227 tree
*convs
, tree
*tpl_convs
)
2229 int my_virtualness
= 0;
2230 tree my_convs
= NULL_TREE
;
2231 tree my_tpl_convs
= NULL_TREE
;
2232 tree child_convs
= NULL_TREE
;
2233 tree child_tpl_convs
= NULL_TREE
;
2236 VEC(tree
) *method_vec
= CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo
));
2239 /* If we have no conversion operators, then don't look. */
2240 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo
)))
2242 *convs
= *tpl_convs
= NULL_TREE
;
2247 if (BINFO_VIRTUAL_P (binfo
))
2250 /* First, locate the unhidden ones at this level. */
2251 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2252 VEC_iterate (tree
, method_vec
, i
, conv
);
2255 tree cur
= OVL_CURRENT (conv
);
2257 if (!DECL_CONV_FN_P (cur
))
2260 if (TREE_CODE (cur
) == TEMPLATE_DECL
)
2262 /* Only template conversions can be overloaded, and we must
2263 flatten them out and check each one individually. */
2266 for (tpls
= conv
; tpls
; tpls
= OVL_NEXT (tpls
))
2268 tree tpl
= OVL_CURRENT (tpls
);
2269 tree type
= DECL_CONV_FN_TYPE (tpl
);
2271 if (check_hidden_convs (binfo
, virtual_depth
, virtualness
,
2272 type
, parent_tpl_convs
, other_tpl_convs
))
2274 my_tpl_convs
= tree_cons (binfo
, tpl
, my_tpl_convs
);
2275 TREE_TYPE (my_tpl_convs
) = type
;
2278 TREE_STATIC (my_tpl_convs
) = 1;
2286 tree name
= DECL_NAME (cur
);
2288 if (!IDENTIFIER_MARKED (name
))
2290 tree type
= DECL_CONV_FN_TYPE (cur
);
2292 if (check_hidden_convs (binfo
, virtual_depth
, virtualness
,
2293 type
, parent_convs
, other_convs
))
2295 my_convs
= tree_cons (binfo
, conv
, my_convs
);
2296 TREE_TYPE (my_convs
) = type
;
2299 TREE_STATIC (my_convs
) = 1;
2302 IDENTIFIER_MARKED (name
) = 1;
2310 parent_convs
= tree_cons (binfo
, my_convs
, parent_convs
);
2312 TREE_STATIC (parent_convs
) = 1;
2317 parent_tpl_convs
= tree_cons (binfo
, my_tpl_convs
, parent_tpl_convs
);
2319 TREE_STATIC (parent_convs
) = 1;
2322 child_convs
= other_convs
;
2323 child_tpl_convs
= other_tpl_convs
;
2325 /* Now iterate over each base, looking for more conversions. */
2326 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2328 tree base_convs
, base_tpl_convs
;
2329 unsigned base_virtualness
;
2331 base_virtualness
= lookup_conversions_r (base_binfo
,
2332 virtual_depth
, virtualness
,
2333 parent_convs
, parent_tpl_convs
,
2334 child_convs
, child_tpl_convs
,
2335 &base_convs
, &base_tpl_convs
);
2336 if (base_virtualness
)
2337 my_virtualness
= virtualness
= 1;
2338 child_convs
= chainon (base_convs
, child_convs
);
2339 child_tpl_convs
= chainon (base_tpl_convs
, child_tpl_convs
);
2342 /* Unmark the conversions found at this level */
2343 for (conv
= my_convs
; conv
; conv
= TREE_CHAIN (conv
))
2344 IDENTIFIER_MARKED (DECL_NAME (OVL_CURRENT (TREE_VALUE (conv
)))) = 0;
2346 *convs
= split_conversions (my_convs
, parent_convs
,
2347 child_convs
, other_convs
);
2348 *tpl_convs
= split_conversions (my_tpl_convs
, parent_tpl_convs
,
2349 child_tpl_convs
, other_tpl_convs
);
2351 return my_virtualness
;
2354 /* Return a TREE_LIST containing all the non-hidden user-defined
2355 conversion functions for TYPE (and its base-classes). The
2356 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2357 function. The TREE_PURPOSE is the BINFO from which the conversion
2358 functions in this node were selected. This function is effectively
2359 performing a set of member lookups as lookup_fnfield does, but
2360 using the type being converted to as the unique key, rather than the
2364 lookup_conversions (tree type
)
2366 tree convs
, tpl_convs
;
2367 tree list
= NULL_TREE
;
2369 complete_type (type
);
2370 if (!TYPE_BINFO (type
))
2373 lookup_conversions_r (TYPE_BINFO (type
), 0, 0,
2374 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
2375 &convs
, &tpl_convs
);
2377 /* Flatten the list-of-lists */
2378 for (; convs
; convs
= TREE_CHAIN (convs
))
2382 for (probe
= TREE_VALUE (convs
); probe
; probe
= next
)
2384 next
= TREE_CHAIN (probe
);
2386 TREE_CHAIN (probe
) = list
;
2391 for (; tpl_convs
; tpl_convs
= TREE_CHAIN (tpl_convs
))
2395 for (probe
= TREE_VALUE (tpl_convs
); probe
; probe
= next
)
2397 next
= TREE_CHAIN (probe
);
2399 TREE_CHAIN (probe
) = list
;
2407 /* Returns the binfo of the first direct or indirect virtual base derived
2408 from BINFO, or NULL if binfo is not via virtual. */
2411 binfo_from_vbase (tree binfo
)
2413 for (; binfo
; binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2415 if (BINFO_VIRTUAL_P (binfo
))
2421 /* Returns the binfo of the first direct or indirect virtual base derived
2422 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2426 binfo_via_virtual (tree binfo
, tree limit
)
2428 if (limit
&& !CLASSTYPE_VBASECLASSES (limit
))
2429 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2432 for (; binfo
&& !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), limit
);
2433 binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2435 if (BINFO_VIRTUAL_P (binfo
))
2441 /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2442 Find the equivalent binfo within whatever graph HERE is located.
2443 This is the inverse of original_binfo. */
2446 copied_binfo (tree binfo
, tree here
)
2448 tree result
= NULL_TREE
;
2450 if (BINFO_VIRTUAL_P (binfo
))
2454 for (t
= here
; BINFO_INHERITANCE_CHAIN (t
);
2455 t
= BINFO_INHERITANCE_CHAIN (t
))
2458 result
= binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (t
));
2460 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2466 cbinfo
= copied_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2467 for (ix
= 0; BINFO_BASE_ITERATE (cbinfo
, ix
, base_binfo
); ix
++)
2468 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
), BINFO_TYPE (binfo
)))
2470 result
= base_binfo
;
2476 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here
), BINFO_TYPE (binfo
)));
2480 gcc_assert (result
);
2485 binfo_for_vbase (tree base
, tree t
)
2491 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
2492 VEC_iterate (tree
, vbases
, ix
, binfo
); ix
++)
2493 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), base
))
2498 /* BINFO is some base binfo of HERE, within some other
2499 hierarchy. Return the equivalent binfo, but in the hierarchy
2500 dominated by HERE. This is the inverse of copied_binfo. If BINFO
2501 is not a base binfo of HERE, returns NULL_TREE. */
2504 original_binfo (tree binfo
, tree here
)
2508 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (here
)))
2510 else if (BINFO_VIRTUAL_P (binfo
))
2511 result
= (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here
))
2512 ? binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (here
))
2514 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2518 base_binfos
= original_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2524 for (ix
= 0; (base_binfo
= BINFO_BASE_BINFO (base_binfos
, ix
)); ix
++)
2525 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
2526 BINFO_TYPE (binfo
)))
2528 result
= base_binfo
;