1 /* Breadth-first and depth-first routines for
2 searching multiple-inheritance lattice for GNU C++.
3 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2002, 2003, 2004, 2005, 2007 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 3, 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 COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* High-level class interface. */
27 #include "coretypes.h"
37 static int is_subobject_of_p (tree
, tree
);
38 static tree
dfs_lookup_base (tree
, void *);
39 static tree
dfs_dcast_hint_pre (tree
, void *);
40 static tree
dfs_dcast_hint_post (tree
, void *);
41 static tree
dfs_debug_mark (tree
, void *);
42 static tree
dfs_walk_once_r (tree
, tree (*pre_fn
) (tree
, void *),
43 tree (*post_fn
) (tree
, void *), void *data
);
44 static void dfs_unmark_r (tree
);
45 static int check_hidden_convs (tree
, int, int, tree
, tree
, tree
);
46 static tree
split_conversions (tree
, tree
, tree
, tree
);
47 static int lookup_conversions_r (tree
, int, int,
48 tree
, tree
, tree
, tree
, tree
*, tree
*);
49 static int look_for_overrides_r (tree
, tree
);
50 static tree
lookup_field_r (tree
, void *);
51 static tree
dfs_accessible_post (tree
, void *);
52 static tree
dfs_walk_once_accessible_r (tree
, bool, bool,
53 tree (*pre_fn
) (tree
, void *),
54 tree (*post_fn
) (tree
, void *),
56 static tree
dfs_walk_once_accessible (tree
, bool,
57 tree (*pre_fn
) (tree
, void *),
58 tree (*post_fn
) (tree
, void *),
60 static tree
dfs_access_in_type (tree
, void *);
61 static access_kind
access_in_type (tree
, tree
);
62 static int protected_accessible_p (tree
, tree
, tree
);
63 static int friend_accessible_p (tree
, tree
, tree
);
64 static int template_self_reference_p (tree
, tree
);
65 static tree
dfs_get_pure_virtuals (tree
, void *);
68 /* Variables for gathering statistics. */
69 #ifdef GATHER_STATISTICS
70 static int n_fields_searched
;
71 static int n_calls_lookup_field
, n_calls_lookup_field_1
;
72 static int n_calls_lookup_fnfields
, n_calls_lookup_fnfields_1
;
73 static int n_calls_get_base_type
;
74 static int n_outer_fields_searched
;
75 static int n_contexts_saved
;
76 #endif /* GATHER_STATISTICS */
79 /* Data for lookup_base and its workers. */
81 struct lookup_base_data_s
83 tree t
; /* type being searched. */
84 tree base
; /* The base type we're looking for. */
85 tree binfo
; /* Found binfo. */
86 bool via_virtual
; /* Found via a virtual path. */
87 bool ambiguous
; /* Found multiply ambiguous */
88 bool repeated_base
; /* Whether there are repeated bases in the
90 bool want_any
; /* Whether we want any matching binfo. */
93 /* Worker function for lookup_base. See if we've found the desired
94 base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
97 dfs_lookup_base (tree binfo
, void *data_
)
99 struct lookup_base_data_s
*data
= (struct lookup_base_data_s
*) data_
;
101 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->base
))
107 = binfo_via_virtual (data
->binfo
, data
->t
) != NULL_TREE
;
109 if (!data
->repeated_base
)
110 /* If there are no repeated bases, we can stop now. */
113 if (data
->want_any
&& !data
->via_virtual
)
114 /* If this is a non-virtual base, then we can't do
118 return dfs_skip_bases
;
122 gcc_assert (binfo
!= data
->binfo
);
124 /* We've found more than one matching binfo. */
127 /* This is immediately ambiguous. */
128 data
->binfo
= NULL_TREE
;
129 data
->ambiguous
= true;
130 return error_mark_node
;
133 /* Prefer one via a non-virtual path. */
134 if (!binfo_via_virtual (binfo
, data
->t
))
137 data
->via_virtual
= false;
141 /* There must be repeated bases, otherwise we'd have stopped
142 on the first base we found. */
143 return dfs_skip_bases
;
150 /* Returns true if type BASE is accessible in T. (BASE is known to be
151 a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
152 true, consider any special access of the current scope, or access
153 bestowed by friendship. */
156 accessible_base_p (tree t
, tree base
, bool consider_local_p
)
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
, consider_local_p
);
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_check_bit
)
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
, !(access
& ba_ignore_scope
)))
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
= (struct dcast_data_s
*) 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
= (struct dcast_data_s
*) 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 class templates and class
473 template partial specializations work correctly. */
474 if (!DECL_DEPENDENT_P (field
))
478 if (DECL_NAME (field
) == name
480 || TREE_CODE (field
) == TYPE_DECL
481 || DECL_CLASS_TEMPLATE_P (field
)))
485 if (name
== vptr_identifier
)
487 /* Give the user what s/he thinks s/he wants. */
488 if (TYPE_POLYMORPHIC_P (type
))
489 return TYPE_VFIELD (type
);
494 /* Return the FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, or
495 NAMESPACE_DECL corresponding to the innermost non-block scope. */
500 /* There are a number of cases we need to be aware of here:
501 current_class_type current_function_decl
508 Those last two make life interesting. If we're in a function which is
509 itself inside a class, we need decls to go into the fn's decls (our
510 second case below). But if we're in a class and the class itself is
511 inside a function, we need decls to go into the decls for the class. To
512 achieve this last goal, we must see if, when both current_class_ptr and
513 current_function_decl are set, the class was declared inside that
514 function. If so, we know to put the decls into the class's scope. */
515 if (current_function_decl
&& current_class_type
516 && ((DECL_FUNCTION_MEMBER_P (current_function_decl
)
517 && same_type_p (DECL_CONTEXT (current_function_decl
),
519 || (DECL_FRIEND_CONTEXT (current_function_decl
)
520 && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl
),
521 current_class_type
))))
522 return current_function_decl
;
523 if (current_class_type
)
524 return current_class_type
;
525 if (current_function_decl
)
526 return current_function_decl
;
527 return current_namespace
;
530 /* Returns nonzero if we are currently in a function scope. Note
531 that this function returns zero if we are within a local class, but
532 not within a member function body of the local class. */
535 at_function_scope_p (void)
537 tree cs
= current_scope ();
538 return cs
&& TREE_CODE (cs
) == FUNCTION_DECL
;
541 /* Returns true if the innermost active scope is a class scope. */
544 at_class_scope_p (void)
546 tree cs
= current_scope ();
547 return cs
&& TYPE_P (cs
);
550 /* Returns true if the innermost active scope is a namespace scope. */
553 at_namespace_scope_p (void)
555 tree cs
= current_scope ();
556 return cs
&& TREE_CODE (cs
) == NAMESPACE_DECL
;
559 /* Return the scope of DECL, as appropriate when doing name-lookup. */
562 context_for_name_lookup (tree decl
)
566 For the purposes of name lookup, after the anonymous union
567 definition, the members of the anonymous union are considered to
568 have been defined in the scope in which the anonymous union is
570 tree context
= DECL_CONTEXT (decl
);
572 while (context
&& TYPE_P (context
) && ANON_AGGR_TYPE_P (context
))
573 context
= TYPE_CONTEXT (context
);
575 context
= global_namespace
;
580 /* The accessibility routines use BINFO_ACCESS for scratch space
581 during the computation of the accessibility of some declaration. */
583 #define BINFO_ACCESS(NODE) \
584 ((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE)))
586 /* Set the access associated with NODE to ACCESS. */
588 #define SET_BINFO_ACCESS(NODE, ACCESS) \
589 ((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \
590 (TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0))
592 /* Called from access_in_type via dfs_walk. Calculate the access to
593 DATA (which is really a DECL) in BINFO. */
596 dfs_access_in_type (tree binfo
, void *data
)
598 tree decl
= (tree
) data
;
599 tree type
= BINFO_TYPE (binfo
);
600 access_kind access
= ak_none
;
602 if (context_for_name_lookup (decl
) == type
)
604 /* If we have descended to the scope of DECL, just note the
605 appropriate access. */
606 if (TREE_PRIVATE (decl
))
608 else if (TREE_PROTECTED (decl
))
609 access
= ak_protected
;
615 /* First, check for an access-declaration that gives us more
616 access to the DECL. The CONST_DECL for an enumeration
617 constant will not have DECL_LANG_SPECIFIC, and thus no
619 if (DECL_LANG_SPECIFIC (decl
) && !DECL_DISCRIMINATOR_P (decl
))
621 tree decl_access
= purpose_member (type
, DECL_ACCESS (decl
));
625 decl_access
= TREE_VALUE (decl_access
);
627 if (decl_access
== access_public_node
)
629 else if (decl_access
== access_protected_node
)
630 access
= ak_protected
;
631 else if (decl_access
== access_private_node
)
642 VEC(tree
,gc
) *accesses
;
644 /* Otherwise, scan our baseclasses, and pick the most favorable
646 accesses
= BINFO_BASE_ACCESSES (binfo
);
647 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
649 tree base_access
= VEC_index (tree
, accesses
, i
);
650 access_kind base_access_now
= BINFO_ACCESS (base_binfo
);
652 if (base_access_now
== ak_none
|| base_access_now
== ak_private
)
653 /* If it was not accessible in the base, or only
654 accessible as a private member, we can't access it
656 base_access_now
= ak_none
;
657 else if (base_access
== access_protected_node
)
658 /* Public and protected members in the base become
660 base_access_now
= ak_protected
;
661 else if (base_access
== access_private_node
)
662 /* Public and protected members in the base become
664 base_access_now
= ak_private
;
666 /* See if the new access, via this base, gives more
667 access than our previous best access. */
668 if (base_access_now
!= ak_none
669 && (access
== ak_none
|| base_access_now
< access
))
671 access
= base_access_now
;
673 /* If the new access is public, we can't do better. */
674 if (access
== ak_public
)
681 /* Note the access to DECL in TYPE. */
682 SET_BINFO_ACCESS (binfo
, access
);
687 /* Return the access to DECL in TYPE. */
690 access_in_type (tree type
, tree decl
)
692 tree binfo
= TYPE_BINFO (type
);
694 /* We must take into account
698 If a name can be reached by several paths through a multiple
699 inheritance graph, the access is that of the path that gives
702 The algorithm we use is to make a post-order depth-first traversal
703 of the base-class hierarchy. As we come up the tree, we annotate
704 each node with the most lenient access. */
705 dfs_walk_once (binfo
, NULL
, dfs_access_in_type
, decl
);
707 return BINFO_ACCESS (binfo
);
710 /* Returns nonzero if it is OK to access DECL through an object
711 indicated by BINFO in the context of DERIVED. */
714 protected_accessible_p (tree decl
, tree derived
, tree binfo
)
718 /* We're checking this clause from [class.access.base]
720 m as a member of N is protected, and the reference occurs in a
721 member or friend of class N, or in a member or friend of a
722 class P derived from N, where m as a member of P is private or
725 Here DERIVED is a possible P and DECL is m. accessible_p will
726 iterate over various values of N, but the access to m in DERIVED
729 Note that I believe that the passage above is wrong, and should read
730 "...is private or protected or public"; otherwise you get bizarre results
731 whereby a public using-decl can prevent you from accessing a protected
732 member of a base. (jason 2000/02/28) */
734 /* If DERIVED isn't derived from m's class, then it can't be a P. */
735 if (!DERIVED_FROM_P (context_for_name_lookup (decl
), derived
))
738 access
= access_in_type (derived
, decl
);
740 /* If m is inaccessible in DERIVED, then it's not a P. */
741 if (access
== ak_none
)
746 When a friend or a member function of a derived class references
747 a protected nonstatic member of a base class, an access check
748 applies in addition to those described earlier in clause
749 _class.access_) Except when forming a pointer to member
750 (_expr.unary.op_), the access must be through a pointer to,
751 reference to, or object of the derived class itself (or any class
752 derived from that class) (_expr.ref_). If the access is to form
753 a pointer to member, the nested-name-specifier shall name the
754 derived class (or any class derived from that class). */
755 if (DECL_NONSTATIC_MEMBER_P (decl
))
757 /* We can tell through what the reference is occurring by
758 chasing BINFO up to the root. */
760 while (BINFO_INHERITANCE_CHAIN (t
))
761 t
= BINFO_INHERITANCE_CHAIN (t
);
763 if (!DERIVED_FROM_P (derived
, BINFO_TYPE (t
)))
770 /* Returns nonzero if SCOPE is a friend of a type which would be able
771 to access DECL through the object indicated by BINFO. */
774 friend_accessible_p (tree scope
, tree decl
, tree binfo
)
776 tree befriending_classes
;
782 if (TREE_CODE (scope
) == FUNCTION_DECL
783 || DECL_FUNCTION_TEMPLATE_P (scope
))
784 befriending_classes
= DECL_BEFRIENDING_CLASSES (scope
);
785 else if (TYPE_P (scope
))
786 befriending_classes
= CLASSTYPE_BEFRIENDING_CLASSES (scope
);
790 for (t
= befriending_classes
; t
; t
= TREE_CHAIN (t
))
791 if (protected_accessible_p (decl
, TREE_VALUE (t
), binfo
))
794 /* Nested classes have the same access as their enclosing types, as
795 per DR 45 (this is a change from the standard). */
797 for (t
= TYPE_CONTEXT (scope
); t
&& TYPE_P (t
); t
= TYPE_CONTEXT (t
))
798 if (protected_accessible_p (decl
, t
, binfo
))
801 if (TREE_CODE (scope
) == FUNCTION_DECL
802 || DECL_FUNCTION_TEMPLATE_P (scope
))
804 /* Perhaps this SCOPE is a member of a class which is a
806 if (DECL_CLASS_SCOPE_P (scope
)
807 && friend_accessible_p (DECL_CONTEXT (scope
), decl
, binfo
))
810 /* Or an instantiation of something which is a friend. */
811 if (DECL_TEMPLATE_INFO (scope
))
814 /* Increment processing_template_decl to make sure that
815 dependent_type_p works correctly. */
816 ++processing_template_decl
;
817 ret
= friend_accessible_p (DECL_TI_TEMPLATE (scope
), decl
, binfo
);
818 --processing_template_decl
;
826 /* Called via dfs_walk_once_accessible from accessible_p */
829 dfs_accessible_post (tree binfo
, void *data ATTRIBUTE_UNUSED
)
831 if (BINFO_ACCESS (binfo
) != ak_none
)
833 tree scope
= current_scope ();
834 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
835 && is_friend (BINFO_TYPE (binfo
), scope
))
842 /* DECL is a declaration from a base class of TYPE, which was the
843 class used to name DECL. Return nonzero if, in the current
844 context, DECL is accessible. If TYPE is actually a BINFO node,
845 then we can tell in what context the access is occurring by looking
846 at the most derived class along the path indicated by BINFO. If
847 CONSIDER_LOCAL is true, do consider special access the current
848 scope or friendship thereof we might have. */
851 accessible_p (tree type
, tree decl
, bool consider_local_p
)
857 /* Nonzero if it's OK to access DECL if it has protected
858 accessibility in TYPE. */
859 int protected_ok
= 0;
861 /* If this declaration is in a block or namespace scope, there's no
863 if (!TYPE_P (context_for_name_lookup (decl
)))
866 /* There is no need to perform access checks inside a thunk. */
867 scope
= current_scope ();
868 if (scope
&& DECL_THUNK_P (scope
))
871 /* In a template declaration, we cannot be sure whether the
872 particular specialization that is instantiated will be a friend
873 or not. Therefore, all access checks are deferred until
874 instantiation. However, PROCESSING_TEMPLATE_DECL is set in the
875 parameter list for a template (because we may see dependent types
876 in default arguments for template parameters), and access
877 checking should be performed in the outermost parameter list. */
878 if (processing_template_decl
879 && (!processing_template_parmlist
|| processing_template_decl
> 1))
885 type
= BINFO_TYPE (type
);
888 binfo
= TYPE_BINFO (type
);
890 /* [class.access.base]
892 A member m is accessible when named in class N if
894 --m as a member of N is public, or
896 --m as a member of N is private, and the reference occurs in a
897 member or friend of class N, or
899 --m as a member of N is protected, and the reference occurs in a
900 member or friend of class N, or in a member or friend of a
901 class P derived from N, where m as a member of P is private or
904 --there exists a base class B of N that is accessible at the point
905 of reference, and m is accessible when named in class B.
907 We walk the base class hierarchy, checking these conditions. */
909 if (consider_local_p
)
911 /* Figure out where the reference is occurring. Check to see if
912 DECL is private or protected in this scope, since that will
913 determine whether protected access is allowed. */
914 if (current_class_type
)
915 protected_ok
= protected_accessible_p (decl
,
916 current_class_type
, binfo
);
918 /* Now, loop through the classes of which we are a friend. */
920 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
))
934 if (!consider_local_p
)
937 /* Walk the hierarchy again, looking for a base class that allows
939 return dfs_walk_once_accessible (binfo
, /*friends=*/true,
940 NULL
, dfs_accessible_post
, NULL
)
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 %qD 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 if (name
== error_mark_node
)
1205 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1207 if (TREE_CODE (xbasetype
) == TREE_BINFO
)
1209 type
= BINFO_TYPE (xbasetype
);
1210 basetype_path
= xbasetype
;
1214 if (!IS_AGGR_TYPE_CODE (TREE_CODE (xbasetype
)))
1217 xbasetype
= NULL_TREE
;
1220 type
= complete_type (type
);
1222 basetype_path
= TYPE_BINFO (type
);
1227 #ifdef GATHER_STATISTICS
1228 n_calls_lookup_field
++;
1229 #endif /* GATHER_STATISTICS */
1231 memset (&lfi
, 0, sizeof (lfi
));
1234 lfi
.want_type
= want_type
;
1235 dfs_walk_all (basetype_path
, &lookup_field_r
, NULL
, &lfi
);
1237 rval_binfo
= lfi
.rval_binfo
;
1239 type
= BINFO_TYPE (rval_binfo
);
1240 errstr
= lfi
.errstr
;
1242 /* If we are not interested in ambiguities, don't report them;
1243 just return NULL_TREE. */
1244 if (!protect
&& lfi
.ambiguous
)
1250 return lfi
.ambiguous
;
1257 In the case of overloaded function names, access control is
1258 applied to the function selected by overloaded resolution.
1260 We cannot check here, even if RVAL is only a single non-static
1261 member function, since we do not know what the "this" pointer
1264 class A { protected: void f(); };
1265 class B : public A {
1272 only the first call to "f" is valid. However, if the function is
1273 static, we can check. */
1275 && !really_overloaded_fn (rval
)
1276 && !(TREE_CODE (rval
) == FUNCTION_DECL
1277 && DECL_NONSTATIC_MEMBER_FUNCTION_P (rval
)))
1278 perform_or_defer_access_check (basetype_path
, rval
, rval
);
1280 if (errstr
&& protect
)
1282 error (errstr
, name
, type
);
1284 print_candidates (lfi
.ambiguous
);
1285 rval
= error_mark_node
;
1288 if (rval
&& is_overloaded_fn (rval
))
1289 rval
= build_baselink (rval_binfo
, basetype_path
, rval
,
1290 (IDENTIFIER_TYPENAME_P (name
)
1291 ? TREE_TYPE (name
): NULL_TREE
));
1295 /* Like lookup_member, except that if we find a function member we
1296 return NULL_TREE. */
1299 lookup_field (tree xbasetype
, tree name
, int protect
, bool want_type
)
1301 tree rval
= lookup_member (xbasetype
, name
, protect
, want_type
);
1303 /* Ignore functions, but propagate the ambiguity list. */
1304 if (!error_operand_p (rval
)
1305 && (rval
&& BASELINK_P (rval
)))
1311 /* Like lookup_member, except that if we find a non-function member we
1312 return NULL_TREE. */
1315 lookup_fnfields (tree xbasetype
, tree name
, int protect
)
1317 tree rval
= lookup_member (xbasetype
, name
, protect
, /*want_type=*/false);
1319 /* Ignore non-functions, but propagate the ambiguity list. */
1320 if (!error_operand_p (rval
)
1321 && (rval
&& !BASELINK_P (rval
)))
1327 /* Return the index in the CLASSTYPE_METHOD_VEC for CLASS_TYPE
1328 corresponding to "operator TYPE ()", or -1 if there is no such
1329 operator. Only CLASS_TYPE itself is searched; this routine does
1330 not scan the base classes of CLASS_TYPE. */
1333 lookup_conversion_operator (tree class_type
, tree type
)
1337 if (TYPE_HAS_CONVERSION (class_type
))
1341 VEC(tree
,gc
) *methods
= CLASSTYPE_METHOD_VEC (class_type
);
1343 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1344 VEC_iterate (tree
, methods
, i
, fn
); ++i
)
1346 /* All the conversion operators come near the beginning of
1347 the class. Therefore, if FN is not a conversion
1348 operator, there is no matching conversion operator in
1350 fn
= OVL_CURRENT (fn
);
1351 if (!DECL_CONV_FN_P (fn
))
1354 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1355 /* All the templated conversion functions are on the same
1356 slot, so remember it. */
1358 else if (same_type_p (DECL_CONV_FN_TYPE (fn
), type
))
1366 /* TYPE is a class type. Return the index of the fields within
1367 the method vector with name NAME, or -1 is no such field exists. */
1370 lookup_fnfields_1 (tree type
, tree name
)
1372 VEC(tree
,gc
) *method_vec
;
1377 if (!CLASS_TYPE_P (type
))
1380 if (COMPLETE_TYPE_P (type
))
1382 if ((name
== ctor_identifier
1383 || name
== base_ctor_identifier
1384 || name
== complete_ctor_identifier
))
1386 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type
))
1387 lazily_declare_fn (sfk_constructor
, type
);
1388 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
1389 lazily_declare_fn (sfk_copy_constructor
, type
);
1391 else if (name
== ansi_assopname(NOP_EXPR
)
1392 && CLASSTYPE_LAZY_ASSIGNMENT_OP (type
))
1393 lazily_declare_fn (sfk_assignment_operator
, type
);
1394 else if ((name
== dtor_identifier
1395 || name
== base_dtor_identifier
1396 || name
== complete_dtor_identifier
1397 || name
== deleting_dtor_identifier
)
1398 && CLASSTYPE_LAZY_DESTRUCTOR (type
))
1399 lazily_declare_fn (sfk_destructor
, type
);
1402 method_vec
= CLASSTYPE_METHOD_VEC (type
);
1406 #ifdef GATHER_STATISTICS
1407 n_calls_lookup_fnfields_1
++;
1408 #endif /* GATHER_STATISTICS */
1410 /* Constructors are first... */
1411 if (name
== ctor_identifier
)
1413 fn
= CLASSTYPE_CONSTRUCTORS (type
);
1414 return fn
? CLASSTYPE_CONSTRUCTOR_SLOT
: -1;
1416 /* and destructors are second. */
1417 if (name
== dtor_identifier
)
1419 fn
= CLASSTYPE_DESTRUCTORS (type
);
1420 return fn
? CLASSTYPE_DESTRUCTOR_SLOT
: -1;
1422 if (IDENTIFIER_TYPENAME_P (name
))
1423 return lookup_conversion_operator (type
, TREE_TYPE (name
));
1425 /* Skip the conversion operators. */
1426 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1427 VEC_iterate (tree
, method_vec
, i
, fn
);
1429 if (!DECL_CONV_FN_P (OVL_CURRENT (fn
)))
1432 /* If the type is complete, use binary search. */
1433 if (COMPLETE_TYPE_P (type
))
1439 hi
= VEC_length (tree
, method_vec
);
1444 #ifdef GATHER_STATISTICS
1445 n_outer_fields_searched
++;
1446 #endif /* GATHER_STATISTICS */
1448 tmp
= VEC_index (tree
, method_vec
, i
);
1449 tmp
= DECL_NAME (OVL_CURRENT (tmp
));
1452 else if (tmp
< name
)
1459 for (; VEC_iterate (tree
, method_vec
, i
, fn
); ++i
)
1461 #ifdef GATHER_STATISTICS
1462 n_outer_fields_searched
++;
1463 #endif /* GATHER_STATISTICS */
1464 if (DECL_NAME (OVL_CURRENT (fn
)) == name
)
1471 /* Like lookup_fnfields_1, except that the name is extracted from
1472 FUNCTION, which is a FUNCTION_DECL or a TEMPLATE_DECL. */
1475 class_method_index_for_fn (tree class_type
, tree function
)
1477 gcc_assert (TREE_CODE (function
) == FUNCTION_DECL
1478 || DECL_FUNCTION_TEMPLATE_P (function
));
1480 return lookup_fnfields_1 (class_type
,
1481 DECL_CONSTRUCTOR_P (function
) ? ctor_identifier
:
1482 DECL_DESTRUCTOR_P (function
) ? dtor_identifier
:
1483 DECL_NAME (function
));
1487 /* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
1488 the class or namespace used to qualify the name. CONTEXT_CLASS is
1489 the class corresponding to the object in which DECL will be used.
1490 Return a possibly modified version of DECL that takes into account
1493 In particular, consider an expression like `B::m' in the context of
1494 a derived class `D'. If `B::m' has been resolved to a BASELINK,
1495 then the most derived class indicated by the BASELINK_BINFO will be
1496 `B', not `D'. This function makes that adjustment. */
1499 adjust_result_of_qualified_name_lookup (tree decl
,
1500 tree qualifying_scope
,
1503 if (context_class
&& context_class
!= error_mark_node
1504 && CLASS_TYPE_P (context_class
)
1505 && CLASS_TYPE_P (qualifying_scope
)
1506 && DERIVED_FROM_P (qualifying_scope
, context_class
)
1507 && BASELINK_P (decl
))
1511 /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
1512 Because we do not yet know which function will be chosen by
1513 overload resolution, we cannot yet check either accessibility
1514 or ambiguity -- in either case, the choice of a static member
1515 function might make the usage valid. */
1516 base
= lookup_base (context_class
, qualifying_scope
,
1517 ba_unique
| ba_quiet
, NULL
);
1520 BASELINK_ACCESS_BINFO (decl
) = base
;
1521 BASELINK_BINFO (decl
)
1522 = lookup_base (base
, BINFO_TYPE (BASELINK_BINFO (decl
)),
1523 ba_unique
| ba_quiet
,
1532 /* Walk the class hierarchy within BINFO, in a depth-first traversal.
1533 PRE_FN is called in preorder, while POST_FN is called in postorder.
1534 If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
1535 walked. If PRE_FN or POST_FN returns a different non-NULL value,
1536 that value is immediately returned and the walk is terminated. One
1537 of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
1538 POST_FN are passed the binfo to examine and the caller's DATA
1539 value. All paths are walked, thus virtual and morally virtual
1540 binfos can be multiply walked. */
1543 dfs_walk_all (tree binfo
, tree (*pre_fn
) (tree
, void *),
1544 tree (*post_fn
) (tree
, void *), void *data
)
1550 /* Call the pre-order walking function. */
1553 rval
= pre_fn (binfo
, data
);
1556 if (rval
== dfs_skip_bases
)
1562 /* Find the next child binfo to walk. */
1563 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1565 rval
= dfs_walk_all (base_binfo
, pre_fn
, post_fn
, data
);
1571 /* Call the post-order walking function. */
1574 rval
= post_fn (binfo
, data
);
1575 gcc_assert (rval
!= dfs_skip_bases
);
1582 /* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1583 that binfos are walked at most once. */
1586 dfs_walk_once_r (tree binfo
, tree (*pre_fn
) (tree
, void *),
1587 tree (*post_fn
) (tree
, void *), void *data
)
1593 /* Call the pre-order walking function. */
1596 rval
= pre_fn (binfo
, data
);
1599 if (rval
== dfs_skip_bases
)
1606 /* Find the next child binfo to walk. */
1607 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1609 if (BINFO_VIRTUAL_P (base_binfo
))
1611 if (BINFO_MARKED (base_binfo
))
1613 BINFO_MARKED (base_binfo
) = 1;
1616 rval
= dfs_walk_once_r (base_binfo
, pre_fn
, post_fn
, data
);
1622 /* Call the post-order walking function. */
1625 rval
= post_fn (binfo
, data
);
1626 gcc_assert (rval
!= dfs_skip_bases
);
1633 /* Worker for dfs_walk_once. Recursively unmark the virtual base binfos of
1637 dfs_unmark_r (tree binfo
)
1642 /* Process the basetypes. */
1643 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1645 if (BINFO_VIRTUAL_P (base_binfo
))
1647 if (!BINFO_MARKED (base_binfo
))
1649 BINFO_MARKED (base_binfo
) = 0;
1651 /* Only walk, if it can contain more virtual bases. */
1652 if (CLASSTYPE_VBASECLASSES (BINFO_TYPE (base_binfo
)))
1653 dfs_unmark_r (base_binfo
);
1657 /* Like dfs_walk_all, except that binfos are not multiply walked. For
1658 non-diamond shaped hierarchies this is the same as dfs_walk_all.
1659 For diamond shaped hierarchies we must mark the virtual bases, to
1660 avoid multiple walks. */
1663 dfs_walk_once (tree binfo
, tree (*pre_fn
) (tree
, void *),
1664 tree (*post_fn
) (tree
, void *), void *data
)
1666 static int active
= 0; /* We must not be called recursively. */
1669 gcc_assert (pre_fn
|| post_fn
);
1670 gcc_assert (!active
);
1673 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
)))
1674 /* We are not diamond shaped, and therefore cannot encounter the
1675 same binfo twice. */
1676 rval
= dfs_walk_all (binfo
, pre_fn
, post_fn
, data
);
1679 rval
= dfs_walk_once_r (binfo
, pre_fn
, post_fn
, data
);
1680 if (!BINFO_INHERITANCE_CHAIN (binfo
))
1682 /* We are at the top of the hierarchy, and can use the
1683 CLASSTYPE_VBASECLASSES list for unmarking the virtual
1685 VEC(tree
,gc
) *vbases
;
1689 for (vbases
= CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)), ix
= 0;
1690 VEC_iterate (tree
, vbases
, ix
, base_binfo
); ix
++)
1691 BINFO_MARKED (base_binfo
) = 0;
1694 dfs_unmark_r (binfo
);
1702 /* Worker function for dfs_walk_once_accessible. Behaves like
1703 dfs_walk_once_r, except (a) FRIENDS_P is true if special
1704 access given by the current context should be considered, (b) ONCE
1705 indicates whether bases should be marked during traversal. */
1708 dfs_walk_once_accessible_r (tree binfo
, bool friends_p
, bool once
,
1709 tree (*pre_fn
) (tree
, void *),
1710 tree (*post_fn
) (tree
, void *), void *data
)
1712 tree rval
= NULL_TREE
;
1716 /* Call the pre-order walking function. */
1719 rval
= pre_fn (binfo
, data
);
1722 if (rval
== dfs_skip_bases
)
1729 /* Find the next child binfo to walk. */
1730 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1732 bool mark
= once
&& BINFO_VIRTUAL_P (base_binfo
);
1734 if (mark
&& BINFO_MARKED (base_binfo
))
1737 /* If the base is inherited via private or protected
1738 inheritance, then we can't see it, unless we are a friend of
1739 the current binfo. */
1740 if (BINFO_BASE_ACCESS (binfo
, ix
) != access_public_node
)
1745 scope
= current_scope ();
1747 || TREE_CODE (scope
) == NAMESPACE_DECL
1748 || !is_friend (BINFO_TYPE (binfo
), scope
))
1753 BINFO_MARKED (base_binfo
) = 1;
1755 rval
= dfs_walk_once_accessible_r (base_binfo
, friends_p
, once
,
1756 pre_fn
, post_fn
, data
);
1762 /* Call the post-order walking function. */
1765 rval
= post_fn (binfo
, data
);
1766 gcc_assert (rval
!= dfs_skip_bases
);
1773 /* Like dfs_walk_once except that only accessible bases are walked.
1774 FRIENDS_P indicates whether friendship of the local context
1775 should be considered when determining accessibility. */
1778 dfs_walk_once_accessible (tree binfo
, bool friends_p
,
1779 tree (*pre_fn
) (tree
, void *),
1780 tree (*post_fn
) (tree
, void *), void *data
)
1782 bool diamond_shaped
= CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
));
1783 tree rval
= dfs_walk_once_accessible_r (binfo
, friends_p
, diamond_shaped
,
1784 pre_fn
, post_fn
, data
);
1788 if (!BINFO_INHERITANCE_CHAIN (binfo
))
1790 /* We are at the top of the hierarchy, and can use the
1791 CLASSTYPE_VBASECLASSES list for unmarking the virtual
1793 VEC(tree
,gc
) *vbases
;
1797 for (vbases
= CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)), ix
= 0;
1798 VEC_iterate (tree
, vbases
, ix
, base_binfo
); ix
++)
1799 BINFO_MARKED (base_binfo
) = 0;
1802 dfs_unmark_r (binfo
);
1807 /* Check that virtual overrider OVERRIDER is acceptable for base function
1808 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
1811 check_final_overrider (tree overrider
, tree basefn
)
1813 tree over_type
= TREE_TYPE (overrider
);
1814 tree base_type
= TREE_TYPE (basefn
);
1815 tree over_return
= TREE_TYPE (over_type
);
1816 tree base_return
= TREE_TYPE (base_type
);
1817 tree over_throw
= TYPE_RAISES_EXCEPTIONS (over_type
);
1818 tree base_throw
= TYPE_RAISES_EXCEPTIONS (base_type
);
1821 if (DECL_INVALID_OVERRIDER_P (overrider
))
1824 if (same_type_p (base_return
, over_return
))
1826 else if ((CLASS_TYPE_P (over_return
) && CLASS_TYPE_P (base_return
))
1827 || (TREE_CODE (base_return
) == TREE_CODE (over_return
)
1828 && POINTER_TYPE_P (base_return
)))
1830 /* Potentially covariant. */
1831 unsigned base_quals
, over_quals
;
1833 fail
= !POINTER_TYPE_P (base_return
);
1836 fail
= cp_type_quals (base_return
) != cp_type_quals (over_return
);
1838 base_return
= TREE_TYPE (base_return
);
1839 over_return
= TREE_TYPE (over_return
);
1841 base_quals
= cp_type_quals (base_return
);
1842 over_quals
= cp_type_quals (over_return
);
1844 if ((base_quals
& over_quals
) != over_quals
)
1847 if (CLASS_TYPE_P (base_return
) && CLASS_TYPE_P (over_return
))
1849 tree binfo
= lookup_base (over_return
, base_return
,
1850 ba_check
| ba_quiet
, NULL
);
1856 && can_convert (TREE_TYPE (base_type
), TREE_TYPE (over_type
)))
1857 /* GNU extension, allow trivial pointer conversions such as
1858 converting to void *, or qualification conversion. */
1860 /* can_convert will permit user defined conversion from a
1861 (reference to) class type. We must reject them. */
1862 over_return
= non_reference (TREE_TYPE (over_type
));
1863 if (CLASS_TYPE_P (over_return
))
1867 warning (0, "deprecated covariant return type for %q+#D",
1869 warning (0, " overriding %q+#D", basefn
);
1883 error ("invalid covariant return type for %q+#D", overrider
);
1884 error (" overriding %q+#D", basefn
);
1888 error ("conflicting return type specified for %q+#D", overrider
);
1889 error (" overriding %q+#D", basefn
);
1891 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
1895 /* Check throw specifier is at least as strict. */
1896 if (!comp_except_specs (base_throw
, over_throw
, 0))
1898 error ("looser throw specifier for %q+#F", overrider
);
1899 error (" overriding %q+#F", basefn
);
1900 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
1907 /* Given a class TYPE, and a function decl FNDECL, look for
1908 virtual functions in TYPE's hierarchy which FNDECL overrides.
1909 We do not look in TYPE itself, only its bases.
1911 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
1912 find that it overrides anything.
1914 We check that every function which is overridden, is correctly
1918 look_for_overrides (tree type
, tree fndecl
)
1920 tree binfo
= TYPE_BINFO (type
);
1925 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1927 tree basetype
= BINFO_TYPE (base_binfo
);
1929 if (TYPE_POLYMORPHIC_P (basetype
))
1930 found
+= look_for_overrides_r (basetype
, fndecl
);
1935 /* Look in TYPE for virtual functions with the same signature as
1939 look_for_overrides_here (tree type
, tree fndecl
)
1943 /* If there are no methods in TYPE (meaning that only implicitly
1944 declared methods will ever be provided for TYPE), then there are
1945 no virtual functions. */
1946 if (!CLASSTYPE_METHOD_VEC (type
))
1949 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fndecl
))
1950 ix
= CLASSTYPE_DESTRUCTOR_SLOT
;
1952 ix
= lookup_fnfields_1 (type
, DECL_NAME (fndecl
));
1955 tree fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
1957 for (; fns
; fns
= OVL_NEXT (fns
))
1959 tree fn
= OVL_CURRENT (fns
);
1961 if (!DECL_VIRTUAL_P (fn
))
1962 /* Not a virtual. */;
1963 else if (DECL_CONTEXT (fn
) != type
)
1964 /* Introduced with a using declaration. */;
1965 else if (DECL_STATIC_FUNCTION_P (fndecl
))
1967 tree btypes
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1968 tree dtypes
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
1969 if (compparms (TREE_CHAIN (btypes
), dtypes
))
1972 else if (same_signature_p (fndecl
, fn
))
1979 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
1980 TYPE itself and its bases. */
1983 look_for_overrides_r (tree type
, tree fndecl
)
1985 tree fn
= look_for_overrides_here (type
, fndecl
);
1988 if (DECL_STATIC_FUNCTION_P (fndecl
))
1990 /* A static member function cannot match an inherited
1991 virtual member function. */
1992 error ("%q+#D cannot be declared", fndecl
);
1993 error (" since %q+#D declared in base class", fn
);
1997 /* It's definitely virtual, even if not explicitly set. */
1998 DECL_VIRTUAL_P (fndecl
) = 1;
1999 check_final_overrider (fndecl
, fn
);
2004 /* We failed to find one declared in this class. Look in its bases. */
2005 return look_for_overrides (type
, fndecl
);
2008 /* Called via dfs_walk from dfs_get_pure_virtuals. */
2011 dfs_get_pure_virtuals (tree binfo
, void *data
)
2013 tree type
= (tree
) data
;
2015 /* We're not interested in primary base classes; the derived class
2016 of which they are a primary base will contain the information we
2018 if (!BINFO_PRIMARY_P (binfo
))
2022 for (virtuals
= BINFO_VIRTUALS (binfo
);
2024 virtuals
= TREE_CHAIN (virtuals
))
2025 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals
)))
2026 VEC_safe_push (tree
, gc
, CLASSTYPE_PURE_VIRTUALS (type
),
2033 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
2036 get_pure_virtuals (tree type
)
2038 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
2039 is going to be overridden. */
2040 CLASSTYPE_PURE_VIRTUALS (type
) = NULL
;
2041 /* Now, run through all the bases which are not primary bases, and
2042 collect the pure virtual functions. We look at the vtable in
2043 each class to determine what pure virtual functions are present.
2044 (A primary base is not interesting because the derived class of
2045 which it is a primary base will contain vtable entries for the
2046 pure virtuals in the base class. */
2047 dfs_walk_once (TYPE_BINFO (type
), NULL
, dfs_get_pure_virtuals
, type
);
2050 /* Debug info for C++ classes can get very large; try to avoid
2051 emitting it everywhere.
2053 Note that this optimization wins even when the target supports
2054 BINCL (if only slightly), and reduces the amount of work for the
2058 maybe_suppress_debug_info (tree t
)
2060 if (write_symbols
== NO_DEBUG
)
2063 /* We might have set this earlier in cp_finish_decl. */
2064 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 0;
2066 /* Always emit the information for each class every time. */
2067 if (flag_emit_class_debug_always
)
2070 /* If we already know how we're handling this class, handle debug info
2072 if (CLASSTYPE_INTERFACE_KNOWN (t
))
2074 if (CLASSTYPE_INTERFACE_ONLY (t
))
2075 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2076 /* else don't set it. */
2078 /* If the class has a vtable, write out the debug info along with
2080 else if (TYPE_CONTAINS_VPTR_P (t
))
2081 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2083 /* Otherwise, just emit the debug info normally. */
2086 /* Note that we want debugging information for a base class of a class
2087 whose vtable is being emitted. Normally, this would happen because
2088 calling the constructor for a derived class implies calling the
2089 constructors for all bases, which involve initializing the
2090 appropriate vptr with the vtable for the base class; but in the
2091 presence of optimization, this initialization may be optimized
2092 away, so we tell finish_vtable_vardecl that we want the debugging
2093 information anyway. */
2096 dfs_debug_mark (tree binfo
, void *data ATTRIBUTE_UNUSED
)
2098 tree t
= BINFO_TYPE (binfo
);
2100 if (CLASSTYPE_DEBUG_REQUESTED (t
))
2101 return dfs_skip_bases
;
2103 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
2108 /* Write out the debugging information for TYPE, whose vtable is being
2109 emitted. Also walk through our bases and note that we want to
2110 write out information for them. This avoids the problem of not
2111 writing any debug info for intermediate basetypes whose
2112 constructors, and thus the references to their vtables, and thus
2113 the vtables themselves, were optimized away. */
2116 note_debug_info_needed (tree type
)
2118 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
2120 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)) = 0;
2121 rest_of_type_compilation (type
, toplevel_bindings_p ());
2124 dfs_walk_all (TYPE_BINFO (type
), dfs_debug_mark
, NULL
, 0);
2128 print_search_statistics (void)
2130 #ifdef GATHER_STATISTICS
2131 fprintf (stderr
, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
2132 n_fields_searched
, n_calls_lookup_field
, n_calls_lookup_field_1
);
2133 fprintf (stderr
, "%d fnfields searched in %d calls to lookup_fnfields\n",
2134 n_outer_fields_searched
, n_calls_lookup_fnfields
);
2135 fprintf (stderr
, "%d calls to get_base_type\n", n_calls_get_base_type
);
2136 #else /* GATHER_STATISTICS */
2137 fprintf (stderr
, "no search statistics\n");
2138 #endif /* GATHER_STATISTICS */
2142 reinit_search_statistics (void)
2144 #ifdef GATHER_STATISTICS
2145 n_fields_searched
= 0;
2146 n_calls_lookup_field
= 0, n_calls_lookup_field_1
= 0;
2147 n_calls_lookup_fnfields
= 0, n_calls_lookup_fnfields_1
= 0;
2148 n_calls_get_base_type
= 0;
2149 n_outer_fields_searched
= 0;
2150 n_contexts_saved
= 0;
2151 #endif /* GATHER_STATISTICS */
2154 /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2155 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2156 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2157 bases have been encountered already in the tree walk. PARENT_CONVS
2158 is the list of lists of conversion functions that could hide CONV
2159 and OTHER_CONVS is the list of lists of conversion functions that
2160 could hide or be hidden by CONV, should virtualness be involved in
2161 the hierarchy. Merely checking the conversion op's name is not
2162 enough because two conversion operators to the same type can have
2163 different names. Return nonzero if we are visible. */
2166 check_hidden_convs (tree binfo
, int virtual_depth
, int virtualness
,
2167 tree to_type
, tree parent_convs
, tree other_convs
)
2171 /* See if we are hidden by a parent conversion. */
2172 for (level
= parent_convs
; level
; level
= TREE_CHAIN (level
))
2173 for (probe
= TREE_VALUE (level
); probe
; probe
= TREE_CHAIN (probe
))
2174 if (same_type_p (to_type
, TREE_TYPE (probe
)))
2177 if (virtual_depth
|| virtualness
)
2179 /* In a virtual hierarchy, we could be hidden, or could hide a
2180 conversion function on the other_convs list. */
2181 for (level
= other_convs
; level
; level
= TREE_CHAIN (level
))
2187 if (!(virtual_depth
|| TREE_STATIC (level
)))
2188 /* Neither is morally virtual, so cannot hide each other. */
2191 if (!TREE_VALUE (level
))
2192 /* They evaporated away already. */
2195 they_hide_us
= (virtual_depth
2196 && original_binfo (binfo
, TREE_PURPOSE (level
)));
2197 we_hide_them
= (!they_hide_us
&& TREE_STATIC (level
)
2198 && original_binfo (TREE_PURPOSE (level
), binfo
));
2200 if (!(we_hide_them
|| they_hide_us
))
2201 /* Neither is within the other, so no hiding can occur. */
2204 for (prev
= &TREE_VALUE (level
), other
= *prev
; other
;)
2206 if (same_type_p (to_type
, TREE_TYPE (other
)))
2209 /* We are hidden. */
2214 /* We hide the other one. */
2215 other
= TREE_CHAIN (other
);
2220 prev
= &TREE_CHAIN (other
);
2228 /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2229 of conversion functions, the first slot will be for the current
2230 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2231 of conversion functions from children of the current binfo,
2232 concatenated with conversions from elsewhere in the hierarchy --
2233 that list begins with OTHER_CONVS. Return a single list of lists
2234 containing only conversions from the current binfo and its
2238 split_conversions (tree my_convs
, tree parent_convs
,
2239 tree child_convs
, tree other_convs
)
2244 /* Remove the original other_convs portion from child_convs. */
2245 for (prev
= NULL
, t
= child_convs
;
2246 t
!= other_convs
; prev
= t
, t
= TREE_CHAIN (t
))
2250 TREE_CHAIN (prev
) = NULL_TREE
;
2252 child_convs
= NULL_TREE
;
2254 /* Attach the child convs to any we had at this level. */
2257 my_convs
= parent_convs
;
2258 TREE_CHAIN (my_convs
) = child_convs
;
2261 my_convs
= child_convs
;
2266 /* Worker for lookup_conversions. Lookup conversion functions in
2267 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in
2268 a morally virtual base, and VIRTUALNESS is nonzero, if we've
2269 encountered virtual bases already in the tree walk. PARENT_CONVS &
2270 PARENT_TPL_CONVS are lists of list of conversions within parent
2271 binfos. OTHER_CONVS and OTHER_TPL_CONVS are conversions found
2272 elsewhere in the tree. Return the conversions found within this
2273 portion of the graph in CONVS and TPL_CONVS. Return nonzero is we
2274 encountered virtualness. We keep template and non-template
2275 conversions separate, to avoid unnecessary type comparisons.
2277 The located conversion functions are held in lists of lists. The
2278 TREE_VALUE of the outer list is the list of conversion functions
2279 found in a particular binfo. The TREE_PURPOSE of both the outer
2280 and inner lists is the binfo at which those conversions were
2281 found. TREE_STATIC is set for those lists within of morally
2282 virtual binfos. The TREE_VALUE of the inner list is the conversion
2283 function or overload itself. The TREE_TYPE of each inner list node
2284 is the converted-to type. */
2287 lookup_conversions_r (tree binfo
,
2288 int virtual_depth
, int virtualness
,
2289 tree parent_convs
, tree parent_tpl_convs
,
2290 tree other_convs
, tree other_tpl_convs
,
2291 tree
*convs
, tree
*tpl_convs
)
2293 int my_virtualness
= 0;
2294 tree my_convs
= NULL_TREE
;
2295 tree my_tpl_convs
= NULL_TREE
;
2296 tree child_convs
= NULL_TREE
;
2297 tree child_tpl_convs
= NULL_TREE
;
2300 VEC(tree
,gc
) *method_vec
= CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo
));
2303 /* If we have no conversion operators, then don't look. */
2304 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo
)))
2306 *convs
= *tpl_convs
= NULL_TREE
;
2311 if (BINFO_VIRTUAL_P (binfo
))
2314 /* First, locate the unhidden ones at this level. */
2315 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2316 VEC_iterate (tree
, method_vec
, i
, conv
);
2319 tree cur
= OVL_CURRENT (conv
);
2321 if (!DECL_CONV_FN_P (cur
))
2324 if (TREE_CODE (cur
) == TEMPLATE_DECL
)
2326 /* Only template conversions can be overloaded, and we must
2327 flatten them out and check each one individually. */
2330 for (tpls
= conv
; tpls
; tpls
= OVL_NEXT (tpls
))
2332 tree tpl
= OVL_CURRENT (tpls
);
2333 tree type
= DECL_CONV_FN_TYPE (tpl
);
2335 if (check_hidden_convs (binfo
, virtual_depth
, virtualness
,
2336 type
, parent_tpl_convs
, other_tpl_convs
))
2338 my_tpl_convs
= tree_cons (binfo
, tpl
, my_tpl_convs
);
2339 TREE_TYPE (my_tpl_convs
) = type
;
2342 TREE_STATIC (my_tpl_convs
) = 1;
2350 tree name
= DECL_NAME (cur
);
2352 if (!IDENTIFIER_MARKED (name
))
2354 tree type
= DECL_CONV_FN_TYPE (cur
);
2356 if (check_hidden_convs (binfo
, virtual_depth
, virtualness
,
2357 type
, parent_convs
, other_convs
))
2359 my_convs
= tree_cons (binfo
, conv
, my_convs
);
2360 TREE_TYPE (my_convs
) = type
;
2363 TREE_STATIC (my_convs
) = 1;
2366 IDENTIFIER_MARKED (name
) = 1;
2374 parent_convs
= tree_cons (binfo
, my_convs
, parent_convs
);
2376 TREE_STATIC (parent_convs
) = 1;
2381 parent_tpl_convs
= tree_cons (binfo
, my_tpl_convs
, parent_tpl_convs
);
2383 TREE_STATIC (parent_tpl_convs
) = 1;
2386 child_convs
= other_convs
;
2387 child_tpl_convs
= other_tpl_convs
;
2389 /* Now iterate over each base, looking for more conversions. */
2390 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2392 tree base_convs
, base_tpl_convs
;
2393 unsigned base_virtualness
;
2395 base_virtualness
= lookup_conversions_r (base_binfo
,
2396 virtual_depth
, virtualness
,
2397 parent_convs
, parent_tpl_convs
,
2398 child_convs
, child_tpl_convs
,
2399 &base_convs
, &base_tpl_convs
);
2400 if (base_virtualness
)
2401 my_virtualness
= virtualness
= 1;
2402 child_convs
= chainon (base_convs
, child_convs
);
2403 child_tpl_convs
= chainon (base_tpl_convs
, child_tpl_convs
);
2406 /* Unmark the conversions found at this level */
2407 for (conv
= my_convs
; conv
; conv
= TREE_CHAIN (conv
))
2408 IDENTIFIER_MARKED (DECL_NAME (OVL_CURRENT (TREE_VALUE (conv
)))) = 0;
2410 *convs
= split_conversions (my_convs
, parent_convs
,
2411 child_convs
, other_convs
);
2412 *tpl_convs
= split_conversions (my_tpl_convs
, parent_tpl_convs
,
2413 child_tpl_convs
, other_tpl_convs
);
2415 return my_virtualness
;
2418 /* Return a TREE_LIST containing all the non-hidden user-defined
2419 conversion functions for TYPE (and its base-classes). The
2420 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2421 function. The TREE_PURPOSE is the BINFO from which the conversion
2422 functions in this node were selected. This function is effectively
2423 performing a set of member lookups as lookup_fnfield does, but
2424 using the type being converted to as the unique key, rather than the
2428 lookup_conversions (tree type
)
2430 tree convs
, tpl_convs
;
2431 tree list
= NULL_TREE
;
2433 complete_type (type
);
2434 if (!TYPE_BINFO (type
))
2437 lookup_conversions_r (TYPE_BINFO (type
), 0, 0,
2438 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
2439 &convs
, &tpl_convs
);
2441 /* Flatten the list-of-lists */
2442 for (; convs
; convs
= TREE_CHAIN (convs
))
2446 for (probe
= TREE_VALUE (convs
); probe
; probe
= next
)
2448 next
= TREE_CHAIN (probe
);
2450 TREE_CHAIN (probe
) = list
;
2455 for (; tpl_convs
; tpl_convs
= TREE_CHAIN (tpl_convs
))
2459 for (probe
= TREE_VALUE (tpl_convs
); probe
; probe
= next
)
2461 next
= TREE_CHAIN (probe
);
2463 TREE_CHAIN (probe
) = list
;
2471 /* Returns the binfo of the first direct or indirect virtual base derived
2472 from BINFO, or NULL if binfo is not via virtual. */
2475 binfo_from_vbase (tree binfo
)
2477 for (; binfo
; binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2479 if (BINFO_VIRTUAL_P (binfo
))
2485 /* Returns the binfo of the first direct or indirect virtual base derived
2486 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2490 binfo_via_virtual (tree binfo
, tree limit
)
2492 if (limit
&& !CLASSTYPE_VBASECLASSES (limit
))
2493 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2496 for (; binfo
&& !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), limit
);
2497 binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2499 if (BINFO_VIRTUAL_P (binfo
))
2505 /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2506 Find the equivalent binfo within whatever graph HERE is located.
2507 This is the inverse of original_binfo. */
2510 copied_binfo (tree binfo
, tree here
)
2512 tree result
= NULL_TREE
;
2514 if (BINFO_VIRTUAL_P (binfo
))
2518 for (t
= here
; BINFO_INHERITANCE_CHAIN (t
);
2519 t
= BINFO_INHERITANCE_CHAIN (t
))
2522 result
= binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (t
));
2524 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2530 cbinfo
= copied_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2531 for (ix
= 0; BINFO_BASE_ITERATE (cbinfo
, ix
, base_binfo
); ix
++)
2532 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
), BINFO_TYPE (binfo
)))
2534 result
= base_binfo
;
2540 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here
), BINFO_TYPE (binfo
)));
2544 gcc_assert (result
);
2549 binfo_for_vbase (tree base
, tree t
)
2553 VEC(tree
,gc
) *vbases
;
2555 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
2556 VEC_iterate (tree
, vbases
, ix
, binfo
); ix
++)
2557 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), base
))
2562 /* BINFO is some base binfo of HERE, within some other
2563 hierarchy. Return the equivalent binfo, but in the hierarchy
2564 dominated by HERE. This is the inverse of copied_binfo. If BINFO
2565 is not a base binfo of HERE, returns NULL_TREE. */
2568 original_binfo (tree binfo
, tree here
)
2572 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (here
)))
2574 else if (BINFO_VIRTUAL_P (binfo
))
2575 result
= (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here
))
2576 ? binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (here
))
2578 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2582 base_binfos
= original_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2588 for (ix
= 0; (base_binfo
= BINFO_BASE_BINFO (base_binfos
, ix
)); ix
++)
2589 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
2590 BINFO_TYPE (binfo
)))
2592 result
= base_binfo
;