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. */
1546 rval = post_fn (binfo, data);
1547 gcc_assert (rval != dfs_skip_bases);
1554 /* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1555 that binfos are walked at most once. */
1558 dfs_walk_once_r (tree binfo, tree (*pre_fn) (tree, void *),
1559 tree (*post_fn) (tree, void *), void *data)
1565 /* Call the pre-order walking function. */
1568 rval = pre_fn (binfo, data);
1571 if (rval == dfs_skip_bases)
1578 /* Find the next child binfo to walk. */
1579 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1581 if (BINFO_VIRTUAL_P (base_binfo))
1583 if (BINFO_MARKED (base_binfo))
1585 BINFO_MARKED (base_binfo) = 1;
1588 rval = dfs_walk_once_r (base_binfo, pre_fn, post_fn, data);
1594 /* Call the post-order walking function. */
1597 rval = post_fn (binfo, data);
1598 gcc_assert (rval != dfs_skip_bases);
1605 /* Worker for dfs_walk_once. Recursively unmark the virtual base binfos of
1609 dfs_unmark_r (tree binfo)
1614 /* Process the basetypes. */
1615 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1617 if (BINFO_VIRTUAL_P (base_binfo))
1619 if (!BINFO_MARKED (base_binfo))
1621 BINFO_MARKED (base_binfo) = 0;
1623 /* Only walk, if it can contain more virtual bases. */
1624 if (CLASSTYPE_VBASECLASSES (BINFO_TYPE (base_binfo)))
1625 dfs_unmark_r (base_binfo);
1629 /* Like dfs_walk_all, except that binfos are not multiply walked. For
1630 non-diamond shaped hierarchies this is the same as dfs_walk_all.
1631 For diamond shaped hierarchies we must mark the virtual bases, to
1632 avoid multiple walks. */
1635 dfs_walk_once (tree binfo, tree (*pre_fn) (tree, void *),
1636 tree (*post_fn) (tree, void *), void *data)
1640 gcc_assert (pre_fn || post_fn);
1642 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo)))
1643 /* We are not diamond shaped, and therefore cannot encounter the
1644 same binfo twice. */
1645 rval = dfs_walk_all (binfo, pre_fn, post_fn, data);
1648 rval = dfs_walk_once_r (binfo, pre_fn, post_fn, data);
1649 if (!BINFO_INHERITANCE_CHAIN (binfo))
1651 /* We are at the top of the hierarchy, and can use the
1652 CLASSTYPE_VBASECLASSES list for unmarking the virtual
1658 for (vbases = CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)), ix = 0;
1659 VEC_iterate (tree, vbases, ix, base_binfo); ix++)
1660 BINFO_MARKED (base_binfo) = 0;
1663 dfs_unmark_r (binfo);
1668 /* Worker function for dfs_walk_once_accessible. Behaves like
1669 dfs_walk_once_r, except (a) FRIENDS_P is true if special
1670 access given by the current context should be considered, (b) ONCE
1671 indicates whether bases should be marked during traversal. */
1674 dfs_walk_once_accessible_r (tree binfo, bool friends_p, bool once,
1675 tree (*pre_fn) (tree, void *),
1676 tree (*post_fn) (tree, void *), void *data)
1678 tree rval = NULL_TREE;
1682 /* Call the pre-order walking function. */
1685 rval = pre_fn (binfo, data);
1688 if (rval == dfs_skip_bases)
1695 /* Find the next child binfo to walk. */
1696 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1698 bool mark = once && BINFO_VIRTUAL_P (base_binfo);
1700 if (mark && BINFO_MARKED (base_binfo))
1703 /* If the base is inherited via private or protected
1704 inheritance, then we can't see it, unless we are a friend of
1705 the current binfo. */
1706 if (BINFO_BASE_ACCESS (binfo, ix) != access_public_node
1707 && !(friends_p && is_friend (BINFO_TYPE (binfo), current_scope ())))
1711 BINFO_MARKED (base_binfo) = 1;
1713 rval = dfs_walk_once_accessible_r (base_binfo, friends_p, once,
1714 pre_fn, post_fn, data);
1720 /* Call the post-order walking function. */
1723 rval = post_fn (binfo, data);
1724 gcc_assert (rval != dfs_skip_bases);
1731 /* Like dfs_walk_once except that only accessible bases are walked.
1732 FRIENDS_P indicates whether friendship of the local context
1733 should be considered when determining accessibility. */
1736 dfs_walk_once_accessible (tree binfo, bool friends_p,
1737 tree (*pre_fn) (tree, void *),
1738 tree (*post_fn) (tree, void *), void *data)
1740 bool diamond_shaped = CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo));
1741 tree rval = dfs_walk_once_accessible_r (binfo, friends_p, diamond_shaped,
1742 pre_fn, post_fn, data);
1746 if (!BINFO_INHERITANCE_CHAIN (binfo))
1748 /* We are at the top of the hierarchy, and can use the
1749 CLASSTYPE_VBASECLASSES list for unmarking the virtual
1755 for (vbases = CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)), ix = 0;
1756 VEC_iterate (tree, vbases, ix, base_binfo); ix++)
1757 BINFO_MARKED (base_binfo) = 0;
1760 dfs_unmark_r (binfo);
1765 /* Check that virtual overrider OVERRIDER is acceptable for base function
1766 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
1769 check_final_overrider (tree overrider, tree basefn)
1771 tree over_type = TREE_TYPE (overrider);
1772 tree base_type = TREE_TYPE (basefn);
1773 tree over_return = TREE_TYPE (over_type);
1774 tree base_return = TREE_TYPE (base_type);
1775 tree over_throw = TYPE_RAISES_EXCEPTIONS (over_type);
1776 tree base_throw = TYPE_RAISES_EXCEPTIONS (base_type);
1779 if (DECL_INVALID_OVERRIDER_P (overrider))
1782 if (same_type_p (base_return, over_return))
1784 else if ((CLASS_TYPE_P (over_return) && CLASS_TYPE_P (base_return))
1785 || (TREE_CODE (base_return) == TREE_CODE (over_return)
1786 && POINTER_TYPE_P (base_return)))
1788 /* Potentially covariant. */
1789 unsigned base_quals, over_quals;
1791 fail = !POINTER_TYPE_P (base_return);
1794 fail = cp_type_quals (base_return) != cp_type_quals (over_return);
1796 base_return = TREE_TYPE (base_return);
1797 over_return = TREE_TYPE (over_return);
1799 base_quals = cp_type_quals (base_return);
1800 over_quals = cp_type_quals (over_return);
1802 if ((base_quals & over_quals) != over_quals)
1805 if (CLASS_TYPE_P (base_return) && CLASS_TYPE_P (over_return))
1807 tree binfo = lookup_base (over_return, base_return,
1808 ba_check | ba_quiet, NULL);
1814 && can_convert (TREE_TYPE (base_type), TREE_TYPE (over_type)))
1815 /* GNU extension, allow trivial pointer conversions such as
1816 converting to void *, or qualification conversion. */
1818 /* can_convert will permit user defined conversion from a
1819 (reference to) class type. We must reject them. */
1820 over_return = non_reference (TREE_TYPE (over_type));
1821 if (CLASS_TYPE_P (over_return))
1835 cp_error_at ("invalid covariant return type for %q#D", overrider);
1836 cp_error_at (" overriding %q#D", basefn);
1840 cp_error_at ("conflicting return type specified for %q#D",
1842 cp_error_at (" overriding %q#D", basefn);
1844 DECL_INVALID_OVERRIDER_P (overrider) = 1;
1848 /* Check throw specifier is at least as strict. */
1849 if (!comp_except_specs (base_throw, over_throw, 0))
1851 cp_error_at ("looser throw specifier for %q#F", overrider);
1852 cp_error_at (" overriding %q#F", basefn);
1853 DECL_INVALID_OVERRIDER_P (overrider) = 1;
1860 /* Given a class TYPE, and a function decl FNDECL, look for
1861 virtual functions in TYPE's hierarchy which FNDECL overrides.
1862 We do not look in TYPE itself, only its bases.
1864 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
1865 find that it overrides anything.
1867 We check that every function which is overridden, is correctly
1871 look_for_overrides (tree type, tree fndecl)
1873 tree binfo = TYPE_BINFO (type);
1878 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1880 tree basetype = BINFO_TYPE (base_binfo);
1882 if (TYPE_POLYMORPHIC_P (basetype))
1883 found += look_for_overrides_r (basetype, fndecl);
1888 /* Look in TYPE for virtual functions with the same signature as
1892 look_for_overrides_here (tree type, tree fndecl)
1896 /* If there are no methods in TYPE (meaning that only implicitly
1897 declared methods will ever be provided for TYPE), then there are
1898 no virtual functions. */
1899 if (!CLASSTYPE_METHOD_VEC (type))
1902 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fndecl))
1903 ix = CLASSTYPE_DESTRUCTOR_SLOT;
1905 ix = lookup_fnfields_1 (type, DECL_NAME (fndecl));
1908 tree fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), ix);
1910 for (; fns; fns = OVL_NEXT (fns))
1912 tree fn = OVL_CURRENT (fns);
1914 if (!DECL_VIRTUAL_P (fn))
1915 /* Not a virtual. */;
1916 else if (DECL_CONTEXT (fn) != type)
1917 /* Introduced with a using declaration. */;
1918 else if (DECL_STATIC_FUNCTION_P (fndecl))
1920 tree btypes = TYPE_ARG_TYPES (TREE_TYPE (fn));
1921 tree dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1922 if (compparms (TREE_CHAIN (btypes), dtypes))
1925 else if (same_signature_p (fndecl, fn))
1932 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
1933 TYPE itself and its bases. */
1936 look_for_overrides_r (tree type, tree fndecl)
1938 tree fn = look_for_overrides_here (type, fndecl);
1941 if (DECL_STATIC_FUNCTION_P (fndecl))
1943 /* A static member function cannot match an inherited
1944 virtual member function. */
1945 cp_error_at ("%q#D cannot be declared", fndecl);
1946 cp_error_at (" since %q#D declared in base class", fn);
1950 /* It's definitely virtual, even if not explicitly set. */
1951 DECL_VIRTUAL_P (fndecl) = 1;
1952 check_final_overrider (fndecl, fn);
1957 /* We failed to find one declared in this class. Look in its bases. */
1958 return look_for_overrides (type, fndecl);
1961 /* Called via dfs_walk from dfs_get_pure_virtuals. */
1964 dfs_get_pure_virtuals (tree binfo, void *data)
1966 tree type = (tree) data;
1968 /* We're not interested in primary base classes; the derived class
1969 of which they are a primary base will contain the information we
1971 if (!BINFO_PRIMARY_P (binfo))
1975 for (virtuals = BINFO_VIRTUALS (binfo);
1977 virtuals = TREE_CHAIN (virtuals))
1978 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals)))
1979 VEC_safe_push (tree, CLASSTYPE_PURE_VIRTUALS (type),
1986 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
1989 get_pure_virtuals (tree type)
1991 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
1992 is going to be overridden. */
1993 CLASSTYPE_PURE_VIRTUALS (type) = NULL;
1994 /* Now, run through all the bases which are not primary bases, and
1995 collect the pure virtual functions. We look at the vtable in
1996 each class to determine what pure virtual functions are present.
1997 (A primary base is not interesting because the derived class of
1998 which it is a primary base will contain vtable entries for the
1999 pure virtuals in the base class. */
2000 dfs_walk_once (TYPE_BINFO (type), NULL, dfs_get_pure_virtuals, type);
2003 /* Debug info for C++ classes can get very large; try to avoid
2004 emitting it everywhere.
2006 Note that this optimization wins even when the target supports
2007 BINCL (if only slightly), and reduces the amount of work for the
2011 maybe_suppress_debug_info (tree t)
2013 if (write_symbols == NO_DEBUG)
2016 /* We might have set this earlier in cp_finish_decl. */
2017 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 0;
2019 /* If we already know how we're handling this class, handle debug info
2021 if (CLASSTYPE_INTERFACE_KNOWN (t))
2023 if (CLASSTYPE_INTERFACE_ONLY (t))
2024 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
2025 /* else don't set it. */
2027 /* If the class has a vtable, write out the debug info along with
2029 else if (TYPE_CONTAINS_VPTR_P (t))
2030 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
2032 /* Otherwise, just emit the debug info normally. */
2035 /* Note that we want debugging information for a base class of a class
2036 whose vtable is being emitted. Normally, this would happen because
2037 calling the constructor for a derived class implies calling the
2038 constructors for all bases, which involve initializing the
2039 appropriate vptr with the vtable for the base class; but in the
2040 presence of optimization, this initialization may be optimized
2041 away, so we tell finish_vtable_vardecl that we want the debugging
2042 information anyway. */
2045 dfs_debug_mark (tree binfo, void *data ATTRIBUTE_UNUSED)
2047 tree t = BINFO_TYPE (binfo);
2049 if (CLASSTYPE_DEBUG_REQUESTED (t))
2050 return dfs_skip_bases;
2052 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
2057 /* Write out the debugging information for TYPE, whose vtable is being
2058 emitted. Also walk through our bases and note that we want to
2059 write out information for them. This avoids the problem of not
2060 writing any debug info for intermediate basetypes whose
2061 constructors, and thus the references to their vtables, and thus
2062 the vtables themselves, were optimized away. */
2065 note_debug_info_needed (tree type)
2067 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
2069 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)) = 0;
2070 rest_of_type_compilation (type, toplevel_bindings_p ());
2073 dfs_walk_all (TYPE_BINFO (type), dfs_debug_mark, NULL, 0);
2077 print_search_statistics (void)
2079 #ifdef GATHER_STATISTICS
2080 fprintf (stderr, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
2081 n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1);
2082 fprintf (stderr, "%d fnfields searched in %d calls to lookup_fnfields\n",
2083 n_outer_fields_searched, n_calls_lookup_fnfields);
2084 fprintf (stderr, "%d calls to get_base_type\n", n_calls_get_base_type);
2085 #else /* GATHER_STATISTICS */
2086 fprintf (stderr, "no search statistics\n");
2087 #endif /* GATHER_STATISTICS */
2091 reinit_search_statistics (void)
2093 #ifdef GATHER_STATISTICS
2094 n_fields_searched = 0;
2095 n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0;
2096 n_calls_lookup_fnfields = 0, n_calls_lookup_fnfields_1 = 0;
2097 n_calls_get_base_type = 0;
2098 n_outer_fields_searched = 0;
2099 n_contexts_saved = 0;
2100 #endif /* GATHER_STATISTICS */
2103 /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2104 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2105 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2106 bases have been encountered already in the tree walk. PARENT_CONVS
2107 is the list of lists of conversion functions that could hide CONV
2108 and OTHER_CONVS is the list of lists of conversion functions that
2109 could hide or be hidden by CONV, should virtualness be involved in
2110 the hierarchy. Merely checking the conversion op's name is not
2111 enough because two conversion operators to the same type can have
2112 different names. Return nonzero if we are visible. */
2115 check_hidden_convs (tree binfo, int virtual_depth, int virtualness,
2116 tree to_type, tree parent_convs, tree other_convs)
2120 /* See if we are hidden by a parent conversion. */
2121 for (level = parent_convs; level; level = TREE_CHAIN (level))
2122 for (probe = TREE_VALUE (level); probe; probe = TREE_CHAIN (probe))
2123 if (same_type_p (to_type, TREE_TYPE (probe)))
2126 if (virtual_depth || virtualness)
2128 /* In a virtual hierarchy, we could be hidden, or could hide a
2129 conversion function on the other_convs list. */
2130 for (level = other_convs; level; level = TREE_CHAIN (level))
2136 if (!(virtual_depth || TREE_STATIC (level)))
2137 /* Neither is morally virtual, so cannot hide each other. */
2140 if (!TREE_VALUE (level))
2141 /* They evaporated away already. */
2144 they_hide_us = (virtual_depth
2145 && original_binfo (binfo, TREE_PURPOSE (level)));
2146 we_hide_them = (!they_hide_us && TREE_STATIC (level)
2147 && original_binfo (TREE_PURPOSE (level), binfo));
2149 if (!(we_hide_them || they_hide_us))
2150 /* Neither is within the other, so no hiding can occur. */
2153 for (prev = &TREE_VALUE (level), other = *prev; other;)
2155 if (same_type_p (to_type, TREE_TYPE (other)))
2158 /* We are hidden. */
2163 /* We hide the other one. */
2164 other = TREE_CHAIN (other);
2169 prev = &TREE_CHAIN (other);
2177 /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2178 of conversion functions, the first slot will be for the current
2179 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2180 of conversion functions from children of the current binfo,
2181 concatenated with conversions from elsewhere in the hierarchy --
2182 that list begins with OTHER_CONVS. Return a single list of lists
2183 containing only conversions from the current binfo and its
2187 split_conversions (tree my_convs, tree parent_convs,
2188 tree child_convs, tree other_convs)
2193 /* Remove the original other_convs portion from child_convs. */
2194 for (prev = NULL, t = child_convs;
2195 t != other_convs; prev = t, t = TREE_CHAIN (t))
2199 TREE_CHAIN (prev) = NULL_TREE;
2201 child_convs = NULL_TREE;
2203 /* Attach the child convs to any we had at this level. */
2206 my_convs = parent_convs;
2207 TREE_CHAIN (my_convs) = child_convs;
2210 my_convs = child_convs;
2215 /* Worker for lookup_conversions. Lookup conversion functions in
2216 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in
2217 a morally virtual base, and VIRTUALNESS is nonzero, if we've
2218 encountered virtual bases already in the tree walk. PARENT_CONVS &
2219 PARENT_TPL_CONVS are lists of list of conversions within parent
2220 binfos. OTHER_CONVS and OTHER_TPL_CONVS are conversions found
2221 elsewhere in the tree. Return the conversions found within this
2222 portion of the graph in CONVS and TPL_CONVS. Return nonzero is we
2223 encountered virtualness. We keep template and non-template
2224 conversions separate, to avoid unnecessary type comparisons.
2226 The located conversion functions are held in lists of lists. The
2227 TREE_VALUE of the outer list is the list of conversion functions
2228 found in a particular binfo. The TREE_PURPOSE of both the outer
2229 and inner lists is the binfo at which those conversions were
2230 found. TREE_STATIC is set for those lists within of morally
2231 virtual binfos. The TREE_VALUE of the inner list is the conversion
2232 function or overload itself. The TREE_TYPE of each inner list node
2233 is the converted-to type. */
2236 lookup_conversions_r (tree binfo,
2237 int virtual_depth, int virtualness,
2238 tree parent_convs, tree parent_tpl_convs,
2239 tree other_convs, tree other_tpl_convs,
2240 tree *convs, tree *tpl_convs)
2242 int my_virtualness = 0;
2243 tree my_convs = NULL_TREE;
2244 tree my_tpl_convs = NULL_TREE;
2245 tree child_convs = NULL_TREE;
2246 tree child_tpl_convs = NULL_TREE;
2249 VEC(tree) *method_vec = CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo));
2252 /* If we have no conversion operators, then don't look. */
2253 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo)))
2255 *convs = *tpl_convs = NULL_TREE;
2260 if (BINFO_VIRTUAL_P (binfo))
2263 /* First, locate the unhidden ones at this level. */
2264 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
2265 VEC_iterate (tree, method_vec, i, conv);
2268 tree cur = OVL_CURRENT (conv);
2270 if (!DECL_CONV_FN_P (cur))
2273 if (TREE_CODE (cur) == TEMPLATE_DECL)
2275 /* Only template conversions can be overloaded, and we must
2276 flatten them out and check each one individually. */
2279 for (tpls = conv; tpls; tpls = OVL_NEXT (tpls))
2281 tree tpl = OVL_CURRENT (tpls);
2282 tree type = DECL_CONV_FN_TYPE (tpl);
2284 if (check_hidden_convs (binfo, virtual_depth, virtualness,
2285 type, parent_tpl_convs, other_tpl_convs))
2287 my_tpl_convs = tree_cons (binfo, tpl, my_tpl_convs);
2288 TREE_TYPE (my_tpl_convs) = type;
2291 TREE_STATIC (my_tpl_convs) = 1;
2299 tree name = DECL_NAME (cur);
2301 if (!IDENTIFIER_MARKED (name))
2303 tree type = DECL_CONV_FN_TYPE (cur);
2305 if (check_hidden_convs (binfo, virtual_depth, virtualness,
2306 type, parent_convs, other_convs))
2308 my_convs = tree_cons (binfo, conv, my_convs);
2309 TREE_TYPE (my_convs) = type;
2312 TREE_STATIC (my_convs) = 1;
2315 IDENTIFIER_MARKED (name) = 1;
2323 parent_convs = tree_cons (binfo, my_convs, parent_convs);
2325 TREE_STATIC (parent_convs) = 1;
2330 parent_tpl_convs = tree_cons (binfo, my_tpl_convs, parent_tpl_convs);
2332 TREE_STATIC (parent_convs) = 1;
2335 child_convs = other_convs;
2336 child_tpl_convs = other_tpl_convs;
2338 /* Now iterate over each base, looking for more conversions. */
2339 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2341 tree base_convs, base_tpl_convs;
2342 unsigned base_virtualness;
2344 base_virtualness = lookup_conversions_r (base_binfo,
2345 virtual_depth, virtualness,
2346 parent_convs, parent_tpl_convs,
2347 child_convs, child_tpl_convs,
2348 &base_convs, &base_tpl_convs);
2349 if (base_virtualness)
2350 my_virtualness = virtualness = 1;
2351 child_convs = chainon (base_convs, child_convs);
2352 child_tpl_convs = chainon (base_tpl_convs, child_tpl_convs);
2355 /* Unmark the conversions found at this level */
2356 for (conv = my_convs; conv; conv = TREE_CHAIN (conv))
2357 IDENTIFIER_MARKED (DECL_NAME (OVL_CURRENT (TREE_VALUE (conv)))) = 0;
2359 *convs = split_conversions (my_convs, parent_convs,
2360 child_convs, other_convs);
2361 *tpl_convs = split_conversions (my_tpl_convs, parent_tpl_convs,
2362 child_tpl_convs, other_tpl_convs);
2364 return my_virtualness;
2367 /* Return a TREE_LIST containing all the non-hidden user-defined
2368 conversion functions for TYPE (and its base-classes). The
2369 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2370 function. The TREE_PURPOSE is the BINFO from which the conversion
2371 functions in this node were selected. This function is effectively
2372 performing a set of member lookups as lookup_fnfield does, but
2373 using the type being converted to as the unique key, rather than the
2377 lookup_conversions (tree type)
2379 tree convs, tpl_convs;
2380 tree list = NULL_TREE;
2382 complete_type (type);
2383 if (!TYPE_BINFO (type))
2386 lookup_conversions_r (TYPE_BINFO (type), 0, 0,
2387 NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
2388 &convs, &tpl_convs);
2390 /* Flatten the list-of-lists */
2391 for (; convs; convs = TREE_CHAIN (convs))
2395 for (probe = TREE_VALUE (convs); probe; probe = next)
2397 next = TREE_CHAIN (probe);
2399 TREE_CHAIN (probe) = list;
2404 for (; tpl_convs; tpl_convs = TREE_CHAIN (tpl_convs))
2408 for (probe = TREE_VALUE (tpl_convs); probe; probe = next)
2410 next = TREE_CHAIN (probe);
2412 TREE_CHAIN (probe) = list;
2420 /* Returns the binfo of the first direct or indirect virtual base derived
2421 from BINFO, or NULL if binfo is not via virtual. */
2424 binfo_from_vbase (tree binfo)
2426 for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
2428 if (BINFO_VIRTUAL_P (binfo))
2434 /* Returns the binfo of the first direct or indirect virtual base derived
2435 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2439 binfo_via_virtual (tree binfo, tree limit)
2441 if (limit && !CLASSTYPE_VBASECLASSES (limit))
2442 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2445 for (; binfo && !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), limit);
2446 binfo = BINFO_INHERITANCE_CHAIN (binfo))
2448 if (BINFO_VIRTUAL_P (binfo))
2454 /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2455 Find the equivalent binfo within whatever graph HERE is located.
2456 This is the inverse of original_binfo. */
2459 copied_binfo (tree binfo, tree here)
2461 tree result = NULL_TREE;
2463 if (BINFO_VIRTUAL_P (binfo))
2467 for (t = here; BINFO_INHERITANCE_CHAIN (t);
2468 t = BINFO_INHERITANCE_CHAIN (t))
2471 result = binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (t));
2473 else if (BINFO_INHERITANCE_CHAIN (binfo))
2479 cbinfo = copied_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
2480 for (ix = 0; BINFO_BASE_ITERATE (cbinfo, ix, base_binfo); ix++)
2481 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), BINFO_TYPE (binfo)))
2483 result = base_binfo;
2489 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here), BINFO_TYPE (binfo)));
2493 gcc_assert (result);
2498 binfo_for_vbase (tree base, tree t)
2504 for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
2505 VEC_iterate (tree, vbases, ix, binfo); ix++)
2506 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), base))
2511 /* BINFO is some base binfo of HERE, within some other
2512 hierarchy. Return the equivalent binfo, but in the hierarchy
2513 dominated by HERE. This is the inverse of copied_binfo. If BINFO
2514 is not a base binfo of HERE, returns NULL_TREE. */
2517 original_binfo (tree binfo, tree here)
2521 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (here)))
2523 else if (BINFO_VIRTUAL_P (binfo))
2524 result = (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here))
2525 ? binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (here))
2527 else if (BINFO_INHERITANCE_CHAIN (binfo))
2531 base_binfos = original_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
2537 for (ix = 0; (base_binfo = BINFO_BASE_BINFO (base_binfos, ix)); ix++)
2538 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
2539 BINFO_TYPE (binfo)))
2541 result = base_binfo;