1 /* Breadth-first and depth-first routines for
2 searching multiple-inheritance lattice for GNU C++.
3 Copyright (C) 1987-2017 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* High-level class interface. */
26 #include "coretypes.h"
30 #include "spellcheck-tree.h"
32 static int is_subobject_of_p (tree
, tree
);
33 static tree
dfs_lookup_base (tree
, void *);
34 static tree
dfs_dcast_hint_pre (tree
, void *);
35 static tree
dfs_dcast_hint_post (tree
, void *);
36 static tree
dfs_debug_mark (tree
, void *);
37 static int check_hidden_convs (tree
, int, int, tree
, tree
, tree
);
38 static tree
split_conversions (tree
, tree
, tree
, tree
);
39 static int lookup_conversions_r (tree
, int, int,
40 tree
, tree
, tree
, tree
, tree
*, tree
*);
41 static int look_for_overrides_r (tree
, tree
);
42 static tree
lookup_field_r (tree
, void *);
43 static tree
dfs_accessible_post (tree
, void *);
44 static tree
dfs_walk_once_accessible (tree
, bool,
45 tree (*pre_fn
) (tree
, void *),
46 tree (*post_fn
) (tree
, void *),
48 static tree
dfs_access_in_type (tree
, void *);
49 static access_kind
access_in_type (tree
, tree
);
50 static tree
dfs_get_pure_virtuals (tree
, void *);
53 /* Variables for gathering statistics. */
54 static int n_fields_searched
;
55 static int n_calls_lookup_field
, n_calls_lookup_field_1
;
56 static int n_calls_lookup_fnfields
, n_calls_lookup_fnfields_1
;
57 static int n_calls_get_base_type
;
58 static int n_outer_fields_searched
;
59 static int n_contexts_saved
;
62 /* Data for lookup_base and its workers. */
64 struct lookup_base_data_s
66 tree t
; /* type being searched. */
67 tree base
; /* The base type we're looking for. */
68 tree binfo
; /* Found binfo. */
69 bool via_virtual
; /* Found via a virtual path. */
70 bool ambiguous
; /* Found multiply ambiguous */
71 bool repeated_base
; /* Whether there are repeated bases in the
73 bool want_any
; /* Whether we want any matching binfo. */
76 /* Worker function for lookup_base. See if we've found the desired
77 base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
80 dfs_lookup_base (tree binfo
, void *data_
)
82 struct lookup_base_data_s
*data
= (struct lookup_base_data_s
*) data_
;
84 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->base
))
90 = binfo_via_virtual (data
->binfo
, data
->t
) != NULL_TREE
;
92 if (!data
->repeated_base
)
93 /* If there are no repeated bases, we can stop now. */
96 if (data
->want_any
&& !data
->via_virtual
)
97 /* If this is a non-virtual base, then we can't do
101 return dfs_skip_bases
;
105 gcc_assert (binfo
!= data
->binfo
);
107 /* We've found more than one matching binfo. */
110 /* This is immediately ambiguous. */
111 data
->binfo
= NULL_TREE
;
112 data
->ambiguous
= true;
113 return error_mark_node
;
116 /* Prefer one via a non-virtual path. */
117 if (!binfo_via_virtual (binfo
, data
->t
))
120 data
->via_virtual
= false;
124 /* There must be repeated bases, otherwise we'd have stopped
125 on the first base we found. */
126 return dfs_skip_bases
;
133 /* Returns true if type BASE is accessible in T. (BASE is known to be
134 a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
135 true, consider any special access of the current scope, or access
136 bestowed by friendship. */
139 accessible_base_p (tree t
, tree base
, bool consider_local_p
)
143 /* [class.access.base]
145 A base class is said to be accessible if an invented public
146 member of the base class is accessible.
148 If BASE is a non-proper base, this condition is trivially
150 if (same_type_p (t
, base
))
152 /* Rather than inventing a public member, we use the implicit
153 public typedef created in the scope of every class. */
154 decl
= TYPE_FIELDS (base
);
155 while (!DECL_SELF_REFERENCE_P (decl
))
156 decl
= DECL_CHAIN (decl
);
157 while (ANON_AGGR_TYPE_P (t
))
158 t
= TYPE_CONTEXT (t
);
159 return accessible_p (t
, decl
, consider_local_p
);
162 /* Lookup BASE in the hierarchy dominated by T. Do access checking as
163 ACCESS specifies. Return the binfo we discover. If KIND_PTR is
164 non-NULL, fill with information about what kind of base we
167 If the base is inaccessible, or ambiguous, then error_mark_node is
168 returned. If the tf_error bit of COMPLAIN is not set, no error
172 lookup_base (tree t
, tree base
, base_access access
,
173 base_kind
*kind_ptr
, tsubst_flags_t complain
)
179 /* "Nothing" is definitely not derived from Base. */
183 *kind_ptr
= bk_not_base
;
187 if (t
== error_mark_node
|| base
== error_mark_node
)
190 *kind_ptr
= bk_not_base
;
191 return error_mark_node
;
193 gcc_assert (TYPE_P (base
));
202 t
= complete_type (TYPE_MAIN_VARIANT (t
));
203 t_binfo
= TYPE_BINFO (t
);
206 base
= TYPE_MAIN_VARIANT (base
);
208 /* If BASE is incomplete, it can't be a base of T--and instantiating it
209 might cause an error. */
210 if (t_binfo
&& CLASS_TYPE_P (base
) && COMPLETE_OR_OPEN_TYPE_P (base
))
212 struct lookup_base_data_s data
;
216 data
.binfo
= NULL_TREE
;
217 data
.ambiguous
= data
.via_virtual
= false;
218 data
.repeated_base
= CLASSTYPE_REPEATED_BASE_P (t
);
219 data
.want_any
= access
== ba_any
;
221 dfs_walk_once (t_binfo
, dfs_lookup_base
, NULL
, &data
);
225 bk
= data
.ambiguous
? bk_ambig
: bk_not_base
;
226 else if (binfo
== t_binfo
)
228 else if (data
.via_virtual
)
239 /* Check that the base is unambiguous and accessible. */
240 if (access
!= ba_any
)
247 if (complain
& tf_error
)
248 error ("%qT is an ambiguous base of %qT", base
, t
);
249 binfo
= error_mark_node
;
253 if ((access
& ba_check_bit
)
254 /* If BASE is incomplete, then BASE and TYPE are probably
255 the same, in which case BASE is accessible. If they
256 are not the same, then TYPE is invalid. In that case,
257 there's no need to issue another error here, and
258 there's no implicit typedef to use in the code that
259 follows, so we skip the check. */
260 && COMPLETE_TYPE_P (base
)
261 && !accessible_base_p (t
, base
, !(access
& ba_ignore_scope
)))
263 if (complain
& tf_error
)
264 error ("%qT is an inaccessible base of %qT", base
, t
);
265 binfo
= error_mark_node
;
266 bk
= bk_inaccessible
;
277 /* Data for dcast_base_hint walker. */
281 tree subtype
; /* The base type we're looking for. */
282 int virt_depth
; /* Number of virtual bases encountered from most
284 tree offset
; /* Best hint offset discovered so far. */
285 bool repeated_base
; /* Whether there are repeated bases in the
289 /* Worker for dcast_base_hint. Search for the base type being cast
293 dfs_dcast_hint_pre (tree binfo
, void *data_
)
295 struct dcast_data_s
*data
= (struct dcast_data_s
*) data_
;
297 if (BINFO_VIRTUAL_P (binfo
))
300 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->subtype
))
302 if (data
->virt_depth
)
304 data
->offset
= ssize_int (-1);
308 data
->offset
= ssize_int (-3);
310 data
->offset
= BINFO_OFFSET (binfo
);
312 return data
->repeated_base
? dfs_skip_bases
: data
->offset
;
318 /* Worker for dcast_base_hint. Track the virtual depth. */
321 dfs_dcast_hint_post (tree binfo
, void *data_
)
323 struct dcast_data_s
*data
= (struct dcast_data_s
*) data_
;
325 if (BINFO_VIRTUAL_P (binfo
))
331 /* The dynamic cast runtime needs a hint about how the static SUBTYPE type
332 started from is related to the required TARGET type, in order to optimize
333 the inheritance graph search. This information is independent of the
334 current context, and ignores private paths, hence get_base_distance is
335 inappropriate. Return a TREE specifying the base offset, BOFF.
336 BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
337 and there are no public virtual SUBTYPE bases.
338 BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
339 BOFF == -2, SUBTYPE is not a public base.
340 BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
343 dcast_base_hint (tree subtype
, tree target
)
345 struct dcast_data_s data
;
347 data
.subtype
= subtype
;
349 data
.offset
= NULL_TREE
;
350 data
.repeated_base
= CLASSTYPE_REPEATED_BASE_P (target
);
352 dfs_walk_once_accessible (TYPE_BINFO (target
), /*friends=*/false,
353 dfs_dcast_hint_pre
, dfs_dcast_hint_post
, &data
);
354 return data
.offset
? data
.offset
: ssize_int (-2);
357 /* Search for a member with name NAME in a multiple inheritance
358 lattice specified by TYPE. If it does not exist, return NULL_TREE.
359 If the member is ambiguously referenced, return `error_mark_node'.
360 Otherwise, return a DECL with the indicated name. If WANT_TYPE is
361 true, type declarations are preferred. */
363 /* Do a 1-level search for NAME as a member of TYPE. The caller must
364 figure out whether it can access this field. (Since it is only one
365 level, this is reasonable.) */
368 lookup_field_1 (tree type
, tree name
, bool want_type
)
372 gcc_assert (identifier_p (name
));
374 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
375 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
376 || TREE_CODE (type
) == TYPENAME_TYPE
)
377 /* The TYPE_FIELDS of a TEMPLATE_TYPE_PARM and
378 BOUND_TEMPLATE_TEMPLATE_PARM are not fields at all;
379 instead TYPE_FIELDS is the TEMPLATE_PARM_INDEX. (Miraculously,
380 the code often worked even when we treated the index as a list
382 The TYPE_FIELDS of TYPENAME_TYPE is its TYPENAME_TYPE_FULLNAME. */
385 if (CLASSTYPE_SORTED_FIELDS (type
))
387 tree
*fields
= &CLASSTYPE_SORTED_FIELDS (type
)->elts
[0];
388 int lo
= 0, hi
= CLASSTYPE_SORTED_FIELDS (type
)->len
;
395 if (GATHER_STATISTICS
)
398 if (DECL_NAME (fields
[i
]) > name
)
400 else if (DECL_NAME (fields
[i
]) < name
)
406 /* We might have a nested class and a field with the
407 same name; we sorted them appropriately via
408 field_decl_cmp, so just look for the first or last
409 field with this name. */
414 while (i
>= lo
&& DECL_NAME (fields
[i
]) == name
);
415 if (!DECL_DECLARES_TYPE_P (field
))
422 while (i
< hi
&& DECL_NAME (fields
[i
]) == name
);
427 field
= strip_using_decl (field
);
428 if (is_overloaded_fn (field
))
438 field
= TYPE_FIELDS (type
);
440 if (GATHER_STATISTICS
)
441 n_calls_lookup_field_1
++;
443 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
447 if (DECL_DECLARES_FUNCTION_P (decl
))
448 /* Functions are kep separately, at the moment. */
451 if (GATHER_STATISTICS
)
454 gcc_assert (DECL_P (field
));
455 if (DECL_NAME (field
) == NULL_TREE
456 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
458 tree temp
= lookup_field_1 (TREE_TYPE (field
), name
, want_type
);
463 if (TREE_CODE (decl
) == USING_DECL
464 && DECL_NAME (decl
) == name
)
466 decl
= strip_using_decl (decl
);
467 if (is_overloaded_fn (decl
))
471 if (DECL_NAME (decl
) == name
472 && (!want_type
|| DECL_DECLARES_TYPE_P (decl
)))
476 if (name
== vptr_identifier
)
478 /* Give the user what s/he thinks s/he wants. */
479 if (TYPE_POLYMORPHIC_P (type
))
480 return TYPE_VFIELD (type
);
485 /* Return the FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, or
486 NAMESPACE_DECL corresponding to the innermost non-block scope. */
491 /* There are a number of cases we need to be aware of here:
492 current_class_type current_function_decl
499 Those last two make life interesting. If we're in a function which is
500 itself inside a class, we need decls to go into the fn's decls (our
501 second case below). But if we're in a class and the class itself is
502 inside a function, we need decls to go into the decls for the class. To
503 achieve this last goal, we must see if, when both current_class_ptr and
504 current_function_decl are set, the class was declared inside that
505 function. If so, we know to put the decls into the class's scope. */
506 if (current_function_decl
&& current_class_type
507 && ((DECL_FUNCTION_MEMBER_P (current_function_decl
)
508 && same_type_p (DECL_CONTEXT (current_function_decl
),
510 || (DECL_FRIEND_CONTEXT (current_function_decl
)
511 && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl
),
512 current_class_type
))))
513 return current_function_decl
;
515 if (current_class_type
)
516 return current_class_type
;
518 if (current_function_decl
)
519 return current_function_decl
;
521 return current_namespace
;
524 /* Returns nonzero if we are currently in a function scope. Note
525 that this function returns zero if we are within a local class, but
526 not within a member function body of the local class. */
529 at_function_scope_p (void)
531 tree cs
= current_scope ();
532 /* Also check cfun to make sure that we're really compiling
533 this function (as opposed to having set current_function_decl
534 for access checking or some such). */
535 return (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
536 && cfun
&& cfun
->decl
== current_function_decl
);
539 /* Returns true if the innermost active scope is a class scope. */
542 at_class_scope_p (void)
544 tree cs
= current_scope ();
545 return cs
&& TYPE_P (cs
);
548 /* Returns true if the innermost active scope is a namespace scope. */
551 at_namespace_scope_p (void)
553 tree cs
= current_scope ();
554 return cs
&& TREE_CODE (cs
) == NAMESPACE_DECL
;
557 /* Return the scope of DECL, as appropriate when doing name-lookup. */
560 context_for_name_lookup (tree decl
)
564 For the purposes of name lookup, after the anonymous union
565 definition, the members of the anonymous union are considered to
566 have been defined in the scope in which the anonymous union is
568 tree context
= DECL_CONTEXT (decl
);
570 while (context
&& TYPE_P (context
)
571 && (ANON_AGGR_TYPE_P (context
) || UNSCOPED_ENUM_P (context
)))
572 context
= TYPE_CONTEXT (context
);
574 context
= global_namespace
;
579 /* Returns true iff DECL is declared in TYPE. */
582 member_declared_in_type (tree decl
, tree type
)
584 /* A normal declaration obviously counts. */
585 if (context_for_name_lookup (decl
) == type
)
587 /* So does a using or access declaration. */
588 if (DECL_LANG_SPECIFIC (decl
) && !DECL_DISCRIMINATOR_P (decl
)
589 && purpose_member (type
, DECL_ACCESS (decl
)))
594 /* The accessibility routines use BINFO_ACCESS for scratch space
595 during the computation of the accessibility of some declaration. */
597 /* Avoid walking up past a declaration of the member. */
600 dfs_access_in_type_pre (tree binfo
, void *data
)
602 tree decl
= (tree
) data
;
603 tree type
= BINFO_TYPE (binfo
);
604 if (member_declared_in_type (decl
, type
))
605 return dfs_skip_bases
;
609 #define BINFO_ACCESS(NODE) \
610 ((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE)))
612 /* Set the access associated with NODE to ACCESS. */
614 #define SET_BINFO_ACCESS(NODE, ACCESS) \
615 ((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \
616 (TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0))
618 /* Called from access_in_type via dfs_walk. Calculate the access to
619 DATA (which is really a DECL) in BINFO. */
622 dfs_access_in_type (tree binfo
, void *data
)
624 tree decl
= (tree
) data
;
625 tree type
= BINFO_TYPE (binfo
);
626 access_kind access
= ak_none
;
628 if (context_for_name_lookup (decl
) == type
)
630 /* If we have descended to the scope of DECL, just note the
631 appropriate access. */
632 if (TREE_PRIVATE (decl
))
634 else if (TREE_PROTECTED (decl
))
635 access
= ak_protected
;
641 /* First, check for an access-declaration that gives us more
642 access to the DECL. */
643 if (DECL_LANG_SPECIFIC (decl
) && !DECL_DISCRIMINATOR_P (decl
))
645 tree decl_access
= purpose_member (type
, DECL_ACCESS (decl
));
649 decl_access
= TREE_VALUE (decl_access
);
651 if (decl_access
== access_public_node
)
653 else if (decl_access
== access_protected_node
)
654 access
= ak_protected
;
655 else if (decl_access
== access_private_node
)
666 vec
<tree
, va_gc
> *accesses
;
668 /* Otherwise, scan our baseclasses, and pick the most favorable
670 accesses
= BINFO_BASE_ACCESSES (binfo
);
671 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
673 tree base_access
= (*accesses
)[i
];
674 access_kind base_access_now
= BINFO_ACCESS (base_binfo
);
676 if (base_access_now
== ak_none
|| base_access_now
== ak_private
)
677 /* If it was not accessible in the base, or only
678 accessible as a private member, we can't access it
680 base_access_now
= ak_none
;
681 else if (base_access
== access_protected_node
)
682 /* Public and protected members in the base become
684 base_access_now
= ak_protected
;
685 else if (base_access
== access_private_node
)
686 /* Public and protected members in the base become
688 base_access_now
= ak_private
;
690 /* See if the new access, via this base, gives more
691 access than our previous best access. */
692 if (base_access_now
!= ak_none
693 && (access
== ak_none
|| base_access_now
< access
))
695 access
= base_access_now
;
697 /* If the new access is public, we can't do better. */
698 if (access
== ak_public
)
705 /* Note the access to DECL in TYPE. */
706 SET_BINFO_ACCESS (binfo
, access
);
711 /* Return the access to DECL in TYPE. */
714 access_in_type (tree type
, tree decl
)
716 tree binfo
= TYPE_BINFO (type
);
718 /* We must take into account
722 If a name can be reached by several paths through a multiple
723 inheritance graph, the access is that of the path that gives
726 The algorithm we use is to make a post-order depth-first traversal
727 of the base-class hierarchy. As we come up the tree, we annotate
728 each node with the most lenient access. */
729 dfs_walk_once (binfo
, dfs_access_in_type_pre
, dfs_access_in_type
, decl
);
731 return BINFO_ACCESS (binfo
);
734 /* Returns nonzero if it is OK to access DECL named in TYPE through an object
735 of OTYPE in the context of DERIVED. */
738 protected_accessible_p (tree decl
, tree derived
, tree type
, tree otype
)
740 /* We're checking this clause from [class.access.base]
742 m as a member of N is protected, and the reference occurs in a
743 member or friend of class N, or in a member or friend of a
744 class P derived from N, where m as a member of P is public, private
747 Here DERIVED is a possible P, DECL is m and TYPE is N. */
749 /* If DERIVED isn't derived from N, then it can't be a P. */
750 if (!DERIVED_FROM_P (type
, derived
))
755 When a friend or a member function of a derived class references
756 a protected nonstatic member of a base class, an access check
757 applies in addition to those described earlier in clause
758 _class.access_) Except when forming a pointer to member
759 (_expr.unary.op_), the access must be through a pointer to,
760 reference to, or object of the derived class itself (or any class
761 derived from that class) (_expr.ref_). If the access is to form
762 a pointer to member, the nested-name-specifier shall name the
763 derived class (or any class derived from that class). */
764 if (DECL_NONSTATIC_MEMBER_P (decl
)
765 && !DERIVED_FROM_P (derived
, otype
))
771 /* Returns nonzero if SCOPE is a type or a friend of a type which would be able
772 to access DECL through TYPE. OTYPE is the type of the object. */
775 friend_accessible_p (tree scope
, tree decl
, tree type
, tree otype
)
777 /* We're checking this clause from [class.access.base]
779 m as a member of N is protected, and the reference occurs in a
780 member or friend of class N, or in a member or friend of a
781 class P derived from N, where m as a member of P is public, private
784 Here DECL is m and TYPE is N. SCOPE is the current context,
785 and we check all its possible Ps. */
786 tree befriending_classes
;
792 if (is_global_friend (scope
))
795 /* Is SCOPE itself a suitable P? */
796 if (TYPE_P (scope
) && protected_accessible_p (decl
, scope
, type
, otype
))
799 if (DECL_DECLARES_FUNCTION_P (scope
))
800 befriending_classes
= DECL_BEFRIENDING_CLASSES (scope
);
801 else if (TYPE_P (scope
))
802 befriending_classes
= CLASSTYPE_BEFRIENDING_CLASSES (scope
);
806 for (t
= befriending_classes
; t
; t
= TREE_CHAIN (t
))
807 if (protected_accessible_p (decl
, TREE_VALUE (t
), type
, otype
))
810 /* Nested classes have the same access as their enclosing types, as
811 per DR 45 (this is a change from C++98). */
813 if (friend_accessible_p (TYPE_CONTEXT (scope
), decl
, type
, otype
))
816 if (DECL_DECLARES_FUNCTION_P (scope
))
818 /* Perhaps this SCOPE is a member of a class which is a
820 if (DECL_CLASS_SCOPE_P (scope
)
821 && friend_accessible_p (DECL_CONTEXT (scope
), decl
, type
, otype
))
825 /* Maybe scope's template is a friend. */
826 if (tree tinfo
= get_template_info (scope
))
828 tree tmpl
= TI_TEMPLATE (tinfo
);
829 if (DECL_CLASS_TEMPLATE_P (tmpl
))
830 tmpl
= TREE_TYPE (tmpl
);
832 tmpl
= DECL_TEMPLATE_RESULT (tmpl
);
835 /* Increment processing_template_decl to make sure that
836 dependent_type_p works correctly. */
837 ++processing_template_decl
;
838 int ret
= friend_accessible_p (tmpl
, decl
, type
, otype
);
839 --processing_template_decl
;
845 /* If is_friend is true, we should have found a befriending class. */
846 gcc_checking_assert (!is_friend (type
, scope
));
851 struct dfs_accessible_data
857 /* Avoid walking up past a declaration of the member. */
860 dfs_accessible_pre (tree binfo
, void *data
)
862 dfs_accessible_data
*d
= (dfs_accessible_data
*)data
;
863 tree type
= BINFO_TYPE (binfo
);
864 if (member_declared_in_type (d
->decl
, type
))
865 return dfs_skip_bases
;
869 /* Called via dfs_walk_once_accessible from accessible_p */
872 dfs_accessible_post (tree binfo
, void *data
)
874 /* access_in_type already set BINFO_ACCESS for us. */
875 access_kind access
= BINFO_ACCESS (binfo
);
876 tree N
= BINFO_TYPE (binfo
);
877 dfs_accessible_data
*d
= (dfs_accessible_data
*)data
;
879 tree scope
= current_nonlambda_scope ();
881 /* A member m is accessible at the point R when named in class N if */
888 /* m as a member of N is public, or */
893 /* m as a member of N is private, and R occurs in a member or friend of
895 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
896 && is_friend (N
, scope
))
903 /* m as a member of N is protected, and R occurs in a member or friend
904 of class N, or in a member or friend of a class P derived from N,
905 where m as a member of P is public, private, or protected */
906 if (friend_accessible_p (scope
, decl
, N
, d
->object_type
))
916 /* Like accessible_p below, but within a template returns true iff DECL is
917 accessible in TYPE to all possible instantiations of the template. */
920 accessible_in_template_p (tree type
, tree decl
)
922 int save_ptd
= processing_template_decl
;
923 processing_template_decl
= 0;
924 int val
= accessible_p (type
, decl
, false);
925 processing_template_decl
= save_ptd
;
929 /* DECL is a declaration from a base class of TYPE, which was the
930 class used to name DECL. Return nonzero if, in the current
931 context, DECL is accessible. If TYPE is actually a BINFO node,
932 then we can tell in what context the access is occurring by looking
933 at the most derived class along the path indicated by BINFO. If
934 CONSIDER_LOCAL is true, do consider special access the current
935 scope or friendship thereof we might have. */
938 accessible_p (tree type
, tree decl
, bool consider_local_p
)
943 /* If this declaration is in a block or namespace scope, there's no
945 if (!TYPE_P (context_for_name_lookup (decl
)))
948 /* There is no need to perform access checks inside a thunk. */
949 if (current_function_decl
&& DECL_THUNK_P (current_function_decl
))
952 /* In a template declaration, we cannot be sure whether the
953 particular specialization that is instantiated will be a friend
954 or not. Therefore, all access checks are deferred until
955 instantiation. However, PROCESSING_TEMPLATE_DECL is set in the
956 parameter list for a template (because we may see dependent types
957 in default arguments for template parameters), and access
958 checking should be performed in the outermost parameter list. */
959 if (processing_template_decl
960 && !expanding_concept ()
961 && (!processing_template_parmlist
|| processing_template_decl
> 1))
964 tree otype
= NULL_TREE
;
967 /* When accessing a non-static member, the most derived type in the
968 binfo chain is the type of the object; remember that type for
969 protected_accessible_p. */
970 for (tree b
= type
; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
971 otype
= BINFO_TYPE (b
);
972 type
= BINFO_TYPE (type
);
977 /* [class.access.base]
979 A member m is accessible when named in class N if
981 --m as a member of N is public, or
983 --m as a member of N is private, and the reference occurs in a
984 member or friend of class N, or
986 --m as a member of N is protected, and the reference occurs in a
987 member or friend of class N, or in a member or friend of a
988 class P derived from N, where m as a member of P is public, private or
991 --there exists a base class B of N that is accessible at the point
992 of reference, and m is accessible when named in class B.
994 We walk the base class hierarchy, checking these conditions. */
996 /* We walk using TYPE_BINFO (type) because access_in_type will set
997 BINFO_ACCESS on it and its bases. */
998 binfo
= TYPE_BINFO (type
);
1000 /* Compute the accessibility of DECL in the class hierarchy
1001 dominated by type. */
1002 access
= access_in_type (type
, decl
);
1003 if (access
== ak_public
)
1006 /* If we aren't considering the point of reference, only the first bullet
1008 if (!consider_local_p
)
1011 dfs_accessible_data d
= { decl
, otype
};
1013 /* Walk the hierarchy again, looking for a base class that allows
1015 return dfs_walk_once_accessible (binfo
, /*friends=*/true,
1017 dfs_accessible_post
, &d
)
1021 struct lookup_field_info
{
1022 /* The type in which we're looking. */
1024 /* The name of the field for which we're looking. */
1026 /* If non-NULL, the current result of the lookup. */
1028 /* The path to RVAL. */
1030 /* If non-NULL, the lookup was ambiguous, and this is a list of the
1033 /* If nonzero, we are looking for types, not data members. */
1035 /* If something went wrong, a message indicating what. */
1039 /* Nonzero for a class member means that it is shared between all objects
1042 [class.member.lookup]:If the resulting set of declarations are not all
1043 from sub-objects of the same type, or the set has a nonstatic member
1044 and includes members from distinct sub-objects, there is an ambiguity
1045 and the program is ill-formed.
1047 This function checks that T contains no nonstatic members. */
1050 shared_member_p (tree t
)
1052 if (VAR_P (t
) || TREE_CODE (t
) == TYPE_DECL \
1053 || TREE_CODE (t
) == CONST_DECL
)
1055 if (is_overloaded_fn (t
))
1057 for (ovl_iterator
iter (get_fns (t
)); iter
; ++iter
)
1058 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (*iter
))
1065 /* Routine to see if the sub-object denoted by the binfo PARENT can be
1066 found as a base class and sub-object of the object denoted by
1070 is_subobject_of_p (tree parent
, tree binfo
)
1074 for (probe
= parent
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
1078 if (BINFO_VIRTUAL_P (probe
))
1079 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (binfo
))
1085 /* DATA is really a struct lookup_field_info. Look for a field with
1086 the name indicated there in BINFO. If this function returns a
1087 non-NULL value it is the result of the lookup. Called from
1088 lookup_field via breadth_first_search. */
1091 lookup_field_r (tree binfo
, void *data
)
1093 struct lookup_field_info
*lfi
= (struct lookup_field_info
*) data
;
1094 tree type
= BINFO_TYPE (binfo
);
1095 tree nval
= NULL_TREE
;
1097 /* If this is a dependent base, don't look in it. */
1098 if (BINFO_DEPENDENT_BASE_P (binfo
))
1101 /* If this base class is hidden by the best-known value so far, we
1102 don't need to look. */
1103 if (lfi
->rval_binfo
&& BINFO_INHERITANCE_CHAIN (binfo
) == lfi
->rval_binfo
1104 && !BINFO_VIRTUAL_P (binfo
))
1105 return dfs_skip_bases
;
1107 /* First, look for a function. There can't be a function and a data
1108 member with the same name, and if there's a function and a type
1109 with the same name, the type is hidden by the function. */
1110 if (!lfi
->want_type
)
1111 nval
= lookup_fnfields_slot (type
, lfi
->name
);
1114 /* Look for a data member or type. */
1115 nval
= lookup_field_1 (type
, lfi
->name
, lfi
->want_type
);
1116 else if (TREE_CODE (nval
) == OVERLOAD
&& OVL_USING_P (nval
))
1118 /* If we have both dependent and non-dependent using-declarations, return
1119 the dependent one rather than an incomplete list of functions. */
1120 tree dep_using
= lookup_field_1 (type
, lfi
->name
, lfi
->want_type
);
1121 if (dep_using
&& TREE_CODE (dep_using
) == USING_DECL
)
1125 /* If there is no declaration with the indicated name in this type,
1126 then there's nothing to do. */
1130 /* If we're looking up a type (as with an elaborated type specifier)
1131 we ignore all non-types we find. */
1132 if (lfi
->want_type
&& !DECL_DECLARES_TYPE_P (nval
))
1134 if (lfi
->name
== TYPE_IDENTIFIER (type
))
1136 /* If the aggregate has no user defined constructors, we allow
1137 it to have fields with the same name as the enclosing type.
1138 If we are looking for that name, find the corresponding
1140 for (nval
= TREE_CHAIN (nval
); nval
; nval
= TREE_CHAIN (nval
))
1141 if (DECL_NAME (nval
) == lfi
->name
1142 && TREE_CODE (nval
) == TYPE_DECL
)
1147 if (!nval
&& CLASSTYPE_NESTED_UTDS (type
) != NULL
)
1149 binding_entry e
= binding_table_find (CLASSTYPE_NESTED_UTDS (type
),
1152 nval
= TYPE_MAIN_DECL (e
->type
);
1158 /* If the lookup already found a match, and the new value doesn't
1159 hide the old one, we might have an ambiguity. */
1161 && !is_subobject_of_p (lfi
->rval_binfo
, binfo
))
1164 if (nval
== lfi
->rval
&& shared_member_p (nval
))
1165 /* The two things are really the same. */
1167 else if (is_subobject_of_p (binfo
, lfi
->rval_binfo
))
1168 /* The previous value hides the new one. */
1172 /* We have a real ambiguity. We keep a chain of all the
1174 if (!lfi
->ambiguous
&& lfi
->rval
)
1176 /* This is the first time we noticed an ambiguity. Add
1177 what we previously thought was a reasonable candidate
1179 lfi
->ambiguous
= tree_cons (NULL_TREE
, lfi
->rval
, NULL_TREE
);
1180 TREE_TYPE (lfi
->ambiguous
) = error_mark_node
;
1183 /* Add the new value. */
1184 lfi
->ambiguous
= tree_cons (NULL_TREE
, nval
, lfi
->ambiguous
);
1185 TREE_TYPE (lfi
->ambiguous
) = error_mark_node
;
1186 lfi
->errstr
= G_("request for member %qD is ambiguous");
1192 lfi
->rval_binfo
= binfo
;
1196 /* Don't look for constructors or destructors in base classes. */
1197 if (IDENTIFIER_CDTOR_P (lfi
->name
))
1198 return dfs_skip_bases
;
1202 /* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO,
1203 BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO,
1204 FUNCTIONS, and OPTYPE respectively. */
1207 build_baselink (tree binfo
, tree access_binfo
, tree functions
, tree optype
)
1211 gcc_assert (TREE_CODE (functions
) == FUNCTION_DECL
1212 || TREE_CODE (functions
) == TEMPLATE_DECL
1213 || TREE_CODE (functions
) == TEMPLATE_ID_EXPR
1214 || TREE_CODE (functions
) == OVERLOAD
);
1215 gcc_assert (!optype
|| TYPE_P (optype
));
1216 gcc_assert (TREE_TYPE (functions
));
1218 baselink
= make_node (BASELINK
);
1219 TREE_TYPE (baselink
) = TREE_TYPE (functions
);
1220 BASELINK_BINFO (baselink
) = binfo
;
1221 BASELINK_ACCESS_BINFO (baselink
) = access_binfo
;
1222 BASELINK_FUNCTIONS (baselink
) = functions
;
1223 BASELINK_OPTYPE (baselink
) = optype
;
1228 /* Look for a member named NAME in an inheritance lattice dominated by
1229 XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
1230 is 1, we enforce accessibility. If PROTECT is zero, then, for an
1231 ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
1232 messages about inaccessible or ambiguous lookup. If PROTECT is 2,
1233 we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
1234 TREE_VALUEs are the list of ambiguous candidates.
1236 WANT_TYPE is 1 when we should only return TYPE_DECLs.
1238 If nothing can be found return NULL_TREE and do not issue an error.
1240 If non-NULL, failure information is written back to AFI. */
1243 lookup_member (tree xbasetype
, tree name
, int protect
, bool want_type
,
1244 tsubst_flags_t complain
, access_failure_info
*afi
)
1246 tree rval
, rval_binfo
= NULL_TREE
;
1247 tree type
= NULL_TREE
, basetype_path
= NULL_TREE
;
1248 struct lookup_field_info lfi
;
1250 /* rval_binfo is the binfo associated with the found member, note,
1251 this can be set with useful information, even when rval is not
1252 set, because it must deal with ALL members, not just non-function
1253 members. It is used for ambiguity checking and the hidden
1254 checks. Whereas rval is only set if a proper (not hidden)
1255 non-function member is found. */
1257 const char *errstr
= 0;
1259 if (name
== error_mark_node
1260 || xbasetype
== NULL_TREE
1261 || xbasetype
== error_mark_node
)
1264 gcc_assert (identifier_p (name
));
1266 if (TREE_CODE (xbasetype
) == TREE_BINFO
)
1268 type
= BINFO_TYPE (xbasetype
);
1269 basetype_path
= xbasetype
;
1273 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype
)))
1276 xbasetype
= NULL_TREE
;
1279 type
= complete_type (type
);
1281 /* Make sure we're looking for a member of the current instantiation in the
1282 right partial specialization. */
1283 if (flag_concepts
&& dependent_type_p (type
))
1284 if (tree t
= currently_open_class (type
))
1288 basetype_path
= TYPE_BINFO (type
);
1293 if (GATHER_STATISTICS
)
1294 n_calls_lookup_field
++;
1296 memset (&lfi
, 0, sizeof (lfi
));
1299 lfi
.want_type
= want_type
;
1300 dfs_walk_all (basetype_path
, &lookup_field_r
, NULL
, &lfi
);
1302 rval_binfo
= lfi
.rval_binfo
;
1304 type
= BINFO_TYPE (rval_binfo
);
1305 errstr
= lfi
.errstr
;
1307 /* If we are not interested in ambiguities, don't report them;
1308 just return NULL_TREE. */
1309 if (!protect
&& lfi
.ambiguous
)
1315 return lfi
.ambiguous
;
1322 In the case of overloaded function names, access control is
1323 applied to the function selected by overloaded resolution.
1325 We cannot check here, even if RVAL is only a single non-static
1326 member function, since we do not know what the "this" pointer
1329 class A { protected: void f(); };
1330 class B : public A {
1337 only the first call to "f" is valid. However, if the function is
1338 static, we can check. */
1340 && !really_overloaded_fn (rval
))
1342 tree decl
= is_overloaded_fn (rval
) ? get_first_fn (rval
) : rval
;
1343 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
)
1344 && !perform_or_defer_access_check (basetype_path
, decl
, decl
,
1346 rval
= error_mark_node
;
1349 if (errstr
&& protect
)
1351 if (complain
& tf_error
)
1353 error (errstr
, name
, type
);
1355 print_candidates (lfi
.ambiguous
);
1357 rval
= error_mark_node
;
1360 if (rval
&& is_overloaded_fn (rval
))
1361 rval
= build_baselink (rval_binfo
, basetype_path
, rval
,
1362 (IDENTIFIER_CONV_OP_P (name
)
1363 ? TREE_TYPE (name
): NULL_TREE
));
1367 /* Helper class for lookup_member_fuzzy. */
1369 class lookup_field_fuzzy_info
1372 lookup_field_fuzzy_info (bool want_type_p
) :
1373 m_want_type_p (want_type_p
), m_candidates () {}
1375 void fuzzy_lookup_fnfields (tree type
);
1376 void fuzzy_lookup_field (tree type
);
1378 /* If true, we are looking for types, not data members. */
1380 /* The result: a vec of identifiers. */
1381 auto_vec
<tree
> m_candidates
;
1384 /* Locate all methods within TYPE, append them to m_candidates. */
1387 lookup_field_fuzzy_info::fuzzy_lookup_fnfields (tree type
)
1389 vec
<tree
, va_gc
> *method_vec
;
1393 if (!CLASS_TYPE_P (type
))
1396 method_vec
= CLASSTYPE_METHOD_VEC (type
);
1400 for (i
= 0; vec_safe_iterate (method_vec
, i
, &fn
); ++i
)
1402 m_candidates
.safe_push (OVL_NAME (fn
));
1405 /* Locate all fields within TYPE, append them to m_candidates. */
1408 lookup_field_fuzzy_info::fuzzy_lookup_field (tree type
)
1410 if (!CLASS_TYPE_P (type
))
1413 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1415 if (!m_want_type_p
|| DECL_DECLARES_TYPE_P (field
))
1416 if (DECL_NAME (field
))
1417 m_candidates
.safe_push (DECL_NAME (field
));
1422 /* Helper function for lookup_member_fuzzy, called via dfs_walk_all
1423 DATA is really a lookup_field_fuzzy_info. Look for a field with
1424 the name indicated there in BINFO. Gathers pertinent identifiers into
1428 lookup_field_fuzzy_r (tree binfo
, void *data
)
1430 lookup_field_fuzzy_info
*lffi
= (lookup_field_fuzzy_info
*) data
;
1431 tree type
= BINFO_TYPE (binfo
);
1433 /* First, look for functions. */
1434 if (!lffi
->m_want_type_p
)
1435 lffi
->fuzzy_lookup_fnfields (type
);
1437 /* Look for data member and types. */
1438 lffi
->fuzzy_lookup_field (type
);
1443 /* Like lookup_member, but try to find the closest match for NAME,
1444 rather than an exact match, and return an identifier (or NULL_TREE).
1448 lookup_member_fuzzy (tree xbasetype
, tree name
, bool want_type_p
)
1450 tree type
= NULL_TREE
, basetype_path
= NULL_TREE
;
1451 struct lookup_field_fuzzy_info
lffi (want_type_p
);
1453 /* rval_binfo is the binfo associated with the found member, note,
1454 this can be set with useful information, even when rval is not
1455 set, because it must deal with ALL members, not just non-function
1456 members. It is used for ambiguity checking and the hidden
1457 checks. Whereas rval is only set if a proper (not hidden)
1458 non-function member is found. */
1460 if (name
== error_mark_node
1461 || xbasetype
== NULL_TREE
1462 || xbasetype
== error_mark_node
)
1465 gcc_assert (identifier_p (name
));
1467 if (TREE_CODE (xbasetype
) == TREE_BINFO
)
1469 type
= BINFO_TYPE (xbasetype
);
1470 basetype_path
= xbasetype
;
1474 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype
)))
1477 xbasetype
= NULL_TREE
;
1480 type
= complete_type (type
);
1482 /* Make sure we're looking for a member of the current instantiation in the
1483 right partial specialization. */
1484 if (flag_concepts
&& dependent_type_p (type
))
1485 type
= currently_open_class (type
);
1488 basetype_path
= TYPE_BINFO (type
);
1493 /* Populate lffi.m_candidates. */
1494 dfs_walk_all (basetype_path
, &lookup_field_fuzzy_r
, NULL
, &lffi
);
1496 return find_closest_identifier (name
, &lffi
.m_candidates
);
1499 /* Like lookup_member, except that if we find a function member we
1500 return NULL_TREE. */
1503 lookup_field (tree xbasetype
, tree name
, int protect
, bool want_type
)
1505 tree rval
= lookup_member (xbasetype
, name
, protect
, want_type
,
1506 tf_warning_or_error
);
1508 /* Ignore functions, but propagate the ambiguity list. */
1509 if (!error_operand_p (rval
)
1510 && (rval
&& BASELINK_P (rval
)))
1516 /* Like lookup_member, except that if we find a non-function member we
1517 return NULL_TREE. */
1520 lookup_fnfields (tree xbasetype
, tree name
, int protect
)
1522 tree rval
= lookup_member (xbasetype
, name
, protect
, /*want_type=*/false,
1523 tf_warning_or_error
);
1525 /* Ignore non-functions, but propagate the ambiguity list. */
1526 if (!error_operand_p (rval
)
1527 && (rval
&& !BASELINK_P (rval
)))
1533 /* Return the conversion operators in CLASS_TYPE corresponding to
1534 "operator TYPE ()". Only CLASS_TYPE itself is searched; this
1535 routine does not scan the base classes of CLASS_TYPE. */
1538 lookup_conversion_operator (tree class_type
, tree type
)
1540 tree tpls
= NULL_TREE
;
1542 if (TYPE_HAS_CONVERSION (class_type
))
1545 vec
<tree
, va_gc
> *methods
= CLASSTYPE_METHOD_VEC (class_type
);
1547 for (int i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1548 vec_safe_iterate (methods
, i
, &fns
); ++i
)
1550 /* All the conversion operators come near the beginning of
1551 the class. Therefore, if FN is not a conversion
1552 operator, there is no matching conversion operator in
1554 tree fn
= OVL_FIRST (fns
);
1555 if (!DECL_CONV_FN_P (fn
))
1558 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1559 /* All the templated conversion functions are on the same
1560 slot, so remember it. */
1562 else if (same_type_p (DECL_CONV_FN_TYPE (fn
), type
))
1570 /* TYPE is a class type. Return the member functions in the method
1571 vector with name NAME. Does not lazily declare implicitly-declared
1572 member functions. */
1575 lookup_fnfields_slot_nolazy (tree type
, tree name
)
1577 vec
<tree
, va_gc
> *method_vec
= CLASSTYPE_METHOD_VEC (type
);
1581 if (GATHER_STATISTICS
)
1582 n_calls_lookup_fnfields_1
++;
1584 if (IDENTIFIER_CONV_OP_P (name
))
1585 return lookup_conversion_operator (type
, TREE_TYPE (name
));
1587 /* Skip the conversion operators. */
1590 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1591 vec_safe_iterate (method_vec
, i
, &fns
);
1593 if (!DECL_CONV_FN_P (OVL_FIRST (fns
)))
1596 /* If the type is complete, use binary search. */
1597 if (COMPLETE_TYPE_P (type
))
1603 hi
= method_vec
->length ();
1608 if (GATHER_STATISTICS
)
1609 n_outer_fields_searched
++;
1611 fns
= (*method_vec
)[i
];
1612 tree fn_name
= OVL_NAME (fns
);
1615 else if (fn_name
< name
)
1622 for (; vec_safe_iterate (method_vec
, i
, &fns
); ++i
)
1624 if (GATHER_STATISTICS
)
1625 n_outer_fields_searched
++;
1626 if (OVL_NAME (fns
) == name
)
1633 /* TYPE is a class type. Return the overloads in
1634 the method vector with name NAME. Lazily create ctors etc. */
1637 lookup_fnfields_slot (tree type
, tree name
)
1639 type
= complete_type (type
);
1641 if (COMPLETE_TYPE_P (type
))
1643 if (IDENTIFIER_CTOR_P (name
))
1645 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type
))
1646 lazily_declare_fn (sfk_constructor
, type
);
1647 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
1648 lazily_declare_fn (sfk_copy_constructor
, type
);
1649 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
1650 lazily_declare_fn (sfk_move_constructor
, type
);
1652 else if (name
== cp_assignment_operator_id (NOP_EXPR
))
1654 if (CLASSTYPE_LAZY_COPY_ASSIGN (type
))
1655 lazily_declare_fn (sfk_copy_assignment
, type
);
1656 if (CLASSTYPE_LAZY_MOVE_ASSIGN (type
))
1657 lazily_declare_fn (sfk_move_assignment
, type
);
1659 else if (IDENTIFIER_DTOR_P (name
))
1661 if (CLASSTYPE_LAZY_DESTRUCTOR (type
))
1662 lazily_declare_fn (sfk_destructor
, type
);
1666 return lookup_fnfields_slot_nolazy (type
, name
);
1669 /* Collect all the conversion operators of KLASS. */
1672 lookup_all_conversions (tree klass
)
1674 tree lkp
= NULL_TREE
;
1676 if (vec
<tree
, va_gc
> *methods
= CLASSTYPE_METHOD_VEC (klass
))
1679 for (int idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1680 methods
->iterate (idx
, &ovl
); ++idx
)
1682 if (!DECL_CONV_FN_P (OVL_FIRST (ovl
)))
1683 /* There are no more conversion functions. */
1686 lkp
= lookup_add (ovl
, lkp
);
1693 /* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
1694 the class or namespace used to qualify the name. CONTEXT_CLASS is
1695 the class corresponding to the object in which DECL will be used.
1696 Return a possibly modified version of DECL that takes into account
1699 In particular, consider an expression like `B::m' in the context of
1700 a derived class `D'. If `B::m' has been resolved to a BASELINK,
1701 then the most derived class indicated by the BASELINK_BINFO will be
1702 `B', not `D'. This function makes that adjustment. */
1705 adjust_result_of_qualified_name_lookup (tree decl
,
1706 tree qualifying_scope
,
1709 if (context_class
&& context_class
!= error_mark_node
1710 && CLASS_TYPE_P (context_class
)
1711 && CLASS_TYPE_P (qualifying_scope
)
1712 && DERIVED_FROM_P (qualifying_scope
, context_class
)
1713 && BASELINK_P (decl
))
1717 /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
1718 Because we do not yet know which function will be chosen by
1719 overload resolution, we cannot yet check either accessibility
1720 or ambiguity -- in either case, the choice of a static member
1721 function might make the usage valid. */
1722 base
= lookup_base (context_class
, qualifying_scope
,
1723 ba_unique
, NULL
, tf_none
);
1724 if (base
&& base
!= error_mark_node
)
1726 BASELINK_ACCESS_BINFO (decl
) = base
;
1728 = lookup_base (base
, BINFO_TYPE (BASELINK_BINFO (decl
)),
1729 ba_unique
, NULL
, tf_none
);
1730 if (decl_binfo
&& decl_binfo
!= error_mark_node
)
1731 BASELINK_BINFO (decl
) = decl_binfo
;
1735 if (BASELINK_P (decl
))
1736 BASELINK_QUALIFIED_P (decl
) = true;
1742 /* Walk the class hierarchy within BINFO, in a depth-first traversal.
1743 PRE_FN is called in preorder, while POST_FN is called in postorder.
1744 If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
1745 walked. If PRE_FN or POST_FN returns a different non-NULL value,
1746 that value is immediately returned and the walk is terminated. One
1747 of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
1748 POST_FN are passed the binfo to examine and the caller's DATA
1749 value. All paths are walked, thus virtual and morally virtual
1750 binfos can be multiply walked. */
1753 dfs_walk_all (tree binfo
, tree (*pre_fn
) (tree
, void *),
1754 tree (*post_fn
) (tree
, void *), void *data
)
1760 /* Call the pre-order walking function. */
1763 rval
= pre_fn (binfo
, data
);
1766 if (rval
== dfs_skip_bases
)
1772 /* Find the next child binfo to walk. */
1773 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1775 rval
= dfs_walk_all (base_binfo
, pre_fn
, post_fn
, data
);
1781 /* Call the post-order walking function. */
1784 rval
= post_fn (binfo
, data
);
1785 gcc_assert (rval
!= dfs_skip_bases
);
1792 /* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1793 that binfos are walked at most once. */
1796 dfs_walk_once_r (tree binfo
, tree (*pre_fn
) (tree
, void *),
1797 tree (*post_fn
) (tree
, void *), hash_set
<tree
> *pset
,
1804 /* Call the pre-order walking function. */
1807 rval
= pre_fn (binfo
, data
);
1810 if (rval
== dfs_skip_bases
)
1817 /* Find the next child binfo to walk. */
1818 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1820 if (BINFO_VIRTUAL_P (base_binfo
))
1821 if (pset
->add (base_binfo
))
1824 rval
= dfs_walk_once_r (base_binfo
, pre_fn
, post_fn
, pset
, data
);
1830 /* Call the post-order walking function. */
1833 rval
= post_fn (binfo
, data
);
1834 gcc_assert (rval
!= dfs_skip_bases
);
1841 /* Like dfs_walk_all, except that binfos are not multiply walked. For
1842 non-diamond shaped hierarchies this is the same as dfs_walk_all.
1843 For diamond shaped hierarchies we must mark the virtual bases, to
1844 avoid multiple walks. */
1847 dfs_walk_once (tree binfo
, tree (*pre_fn
) (tree
, void *),
1848 tree (*post_fn
) (tree
, void *), void *data
)
1850 static int active
= 0; /* We must not be called recursively. */
1853 gcc_assert (pre_fn
|| post_fn
);
1854 gcc_assert (!active
);
1857 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
)))
1858 /* We are not diamond shaped, and therefore cannot encounter the
1859 same binfo twice. */
1860 rval
= dfs_walk_all (binfo
, pre_fn
, post_fn
, data
);
1863 hash_set
<tree
> pset
;
1864 rval
= dfs_walk_once_r (binfo
, pre_fn
, post_fn
, &pset
, data
);
1872 /* Worker function for dfs_walk_once_accessible. Behaves like
1873 dfs_walk_once_r, except (a) FRIENDS_P is true if special
1874 access given by the current context should be considered, (b) ONCE
1875 indicates whether bases should be marked during traversal. */
1878 dfs_walk_once_accessible_r (tree binfo
, bool friends_p
, hash_set
<tree
> *pset
,
1879 tree (*pre_fn
) (tree
, void *),
1880 tree (*post_fn
) (tree
, void *), void *data
)
1882 tree rval
= NULL_TREE
;
1886 /* Call the pre-order walking function. */
1889 rval
= pre_fn (binfo
, data
);
1892 if (rval
== dfs_skip_bases
)
1899 /* Find the next child binfo to walk. */
1900 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1902 bool mark
= pset
&& BINFO_VIRTUAL_P (base_binfo
);
1904 if (mark
&& pset
->contains (base_binfo
))
1907 /* If the base is inherited via private or protected
1908 inheritance, then we can't see it, unless we are a friend of
1909 the current binfo. */
1910 if (BINFO_BASE_ACCESS (binfo
, ix
) != access_public_node
)
1915 scope
= current_scope ();
1917 || TREE_CODE (scope
) == NAMESPACE_DECL
1918 || !is_friend (BINFO_TYPE (binfo
), scope
))
1923 pset
->add (base_binfo
);
1925 rval
= dfs_walk_once_accessible_r (base_binfo
, friends_p
, pset
,
1926 pre_fn
, post_fn
, data
);
1932 /* Call the post-order walking function. */
1935 rval
= post_fn (binfo
, data
);
1936 gcc_assert (rval
!= dfs_skip_bases
);
1943 /* Like dfs_walk_once except that only accessible bases are walked.
1944 FRIENDS_P indicates whether friendship of the local context
1945 should be considered when determining accessibility. */
1948 dfs_walk_once_accessible (tree binfo
, bool friends_p
,
1949 tree (*pre_fn
) (tree
, void *),
1950 tree (*post_fn
) (tree
, void *), void *data
)
1952 hash_set
<tree
> *pset
= NULL
;
1953 if (CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
)))
1954 pset
= new hash_set
<tree
>;
1955 tree rval
= dfs_walk_once_accessible_r (binfo
, friends_p
, pset
,
1956 pre_fn
, post_fn
, data
);
1963 /* Return true iff the code of T is CODE, and it has compatible
1967 matches_code_and_type_p (tree t
, enum tree_code code
, tree type
)
1969 if (TREE_CODE (t
) != code
)
1971 if (!cxx_types_compatible_p (TREE_TYPE (t
), type
))
1976 /* Subroutine of direct_accessor_p and reference_accessor_p.
1977 Determine if COMPONENT_REF is a simple field lookup of this->FIELD_DECL.
1978 We expect a tree of the form:
1983 <field_decl (FIELD_DECL)>>>. */
1986 field_access_p (tree component_ref
, tree field_decl
, tree field_type
)
1988 if (!matches_code_and_type_p (component_ref
, COMPONENT_REF
, field_type
))
1991 tree indirect_ref
= TREE_OPERAND (component_ref
, 0);
1992 if (TREE_CODE (indirect_ref
) != INDIRECT_REF
)
1995 tree ptr
= STRIP_NOPS (TREE_OPERAND (indirect_ref
, 0));
1996 if (!is_this_parameter (ptr
))
1999 /* Must access the correct field. */
2000 if (TREE_OPERAND (component_ref
, 1) != field_decl
)
2005 /* Subroutine of field_accessor_p.
2007 Assuming that INIT_EXPR has already had its code and type checked,
2008 determine if it is a simple accessor for FIELD_DECL
2009 (of type FIELD_TYPE).
2011 Specifically, a simple accessor within struct S of the form:
2012 T get_field () { return m_field; }
2013 should have a DECL_SAVED_TREE of the form:
2022 <field_decl (FIELD_DECL)>>>. */
2025 direct_accessor_p (tree init_expr
, tree field_decl
, tree field_type
)
2027 tree result_decl
= TREE_OPERAND (init_expr
, 0);
2028 if (!matches_code_and_type_p (result_decl
, RESULT_DECL
, field_type
))
2031 tree component_ref
= STRIP_NOPS (TREE_OPERAND (init_expr
, 1));
2032 if (!field_access_p (component_ref
, field_decl
, field_type
))
2038 /* Subroutine of field_accessor_p.
2040 Assuming that INIT_EXPR has already had its code and type checked,
2041 determine if it is a "reference" accessor for FIELD_DECL
2042 (of type FIELD_REFERENCE_TYPE).
2044 Specifically, a simple accessor within struct S of the form:
2045 T& get_field () { return m_field; }
2046 should have a DECL_SAVED_TREE of the form:
2056 <field (FIELD_DECL)>>>>>>. */
2058 reference_accessor_p (tree init_expr
, tree field_decl
, tree field_type
,
2059 tree field_reference_type
)
2061 tree result_decl
= TREE_OPERAND (init_expr
, 0);
2062 if (!matches_code_and_type_p (result_decl
, RESULT_DECL
, field_reference_type
))
2065 tree field_pointer_type
= build_pointer_type (field_type
);
2066 tree addr_expr
= STRIP_NOPS (TREE_OPERAND (init_expr
, 1));
2067 if (!matches_code_and_type_p (addr_expr
, ADDR_EXPR
, field_pointer_type
))
2070 tree component_ref
= STRIP_NOPS (TREE_OPERAND (addr_expr
, 0));
2072 if (!field_access_p (component_ref
, field_decl
, field_type
))
2078 /* Return true if FN is an accessor method for FIELD_DECL.
2079 i.e. a method of the form { return FIELD; }, with no
2082 If CONST_P, then additionally require that FN be a const
2086 field_accessor_p (tree fn
, tree field_decl
, bool const_p
)
2088 if (TREE_CODE (fn
) != FUNCTION_DECL
)
2091 /* We don't yet support looking up static data, just fields. */
2092 if (TREE_CODE (field_decl
) != FIELD_DECL
)
2095 tree fntype
= TREE_TYPE (fn
);
2096 if (TREE_CODE (fntype
) != METHOD_TYPE
)
2099 /* If the field is accessed via a const "this" argument, verify
2100 that the "this" parameter is const. */
2103 tree this_type
= type_of_this_parm (fntype
);
2104 if (!TYPE_READONLY (this_type
))
2108 tree saved_tree
= DECL_SAVED_TREE (fn
);
2110 if (saved_tree
== NULL_TREE
)
2113 if (TREE_CODE (saved_tree
) != RETURN_EXPR
)
2116 tree init_expr
= TREE_OPERAND (saved_tree
, 0);
2117 if (TREE_CODE (init_expr
) != INIT_EXPR
)
2120 /* Determine if this is a simple accessor within struct S of the form:
2121 T get_field () { return m_field; }. */
2122 tree field_type
= TREE_TYPE (field_decl
);
2123 if (cxx_types_compatible_p (TREE_TYPE (init_expr
), field_type
))
2124 return direct_accessor_p (init_expr
, field_decl
, field_type
);
2126 /* Failing that, determine if it is an accessor of the form:
2127 T& get_field () { return m_field; }. */
2128 tree field_reference_type
= cp_build_reference_type (field_type
, false);
2129 if (cxx_types_compatible_p (TREE_TYPE (init_expr
), field_reference_type
))
2130 return reference_accessor_p (init_expr
, field_decl
, field_type
,
2131 field_reference_type
);
2136 /* Callback data for dfs_locate_field_accessor_pre. */
2138 struct locate_field_data
2140 locate_field_data (tree field_decl_
, bool const_p_
)
2141 : field_decl (field_decl_
), const_p (const_p_
) {}
2147 /* Return a FUNCTION_DECL that is an "accessor" method for DATA, a FIELD_DECL,
2148 callable via binfo, if one exists, otherwise return NULL_TREE.
2150 Callback for dfs_walk_once_accessible for use within
2151 locate_field_accessor. */
2154 dfs_locate_field_accessor_pre (tree binfo
, void *data
)
2156 locate_field_data
*lfd
= (locate_field_data
*)data
;
2157 tree type
= BINFO_TYPE (binfo
);
2159 vec
<tree
, va_gc
> *method_vec
;
2163 if (!CLASS_TYPE_P (type
))
2166 method_vec
= CLASSTYPE_METHOD_VEC (type
);
2170 for (i
= 0; vec_safe_iterate (method_vec
, i
, &fn
); ++i
)
2172 if (field_accessor_p (fn
, lfd
->field_decl
, lfd
->const_p
))
2178 /* Return a FUNCTION_DECL that is an "accessor" method for FIELD_DECL,
2179 callable via BASETYPE_PATH, if one exists, otherwise return NULL_TREE. */
2182 locate_field_accessor (tree basetype_path
, tree field_decl
, bool const_p
)
2184 if (TREE_CODE (basetype_path
) != TREE_BINFO
)
2187 /* Walk the hierarchy, looking for a method of some base class that allows
2188 access to the field. */
2189 locate_field_data
lfd (field_decl
, const_p
);
2190 return dfs_walk_once_accessible (basetype_path
, /*friends=*/true,
2191 dfs_locate_field_accessor_pre
,
2195 /* Check that virtual overrider OVERRIDER is acceptable for base function
2196 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
2199 check_final_overrider (tree overrider
, tree basefn
)
2201 tree over_type
= TREE_TYPE (overrider
);
2202 tree base_type
= TREE_TYPE (basefn
);
2203 tree over_return
= fndecl_declared_return_type (overrider
);
2204 tree base_return
= fndecl_declared_return_type (basefn
);
2205 tree over_throw
, base_throw
;
2209 if (DECL_INVALID_OVERRIDER_P (overrider
))
2212 if (same_type_p (base_return
, over_return
))
2214 else if ((CLASS_TYPE_P (over_return
) && CLASS_TYPE_P (base_return
))
2215 || (TREE_CODE (base_return
) == TREE_CODE (over_return
)
2216 && POINTER_TYPE_P (base_return
)))
2218 /* Potentially covariant. */
2219 unsigned base_quals
, over_quals
;
2221 fail
= !POINTER_TYPE_P (base_return
);
2224 fail
= cp_type_quals (base_return
) != cp_type_quals (over_return
);
2226 base_return
= TREE_TYPE (base_return
);
2227 over_return
= TREE_TYPE (over_return
);
2229 base_quals
= cp_type_quals (base_return
);
2230 over_quals
= cp_type_quals (over_return
);
2232 if ((base_quals
& over_quals
) != over_quals
)
2235 if (CLASS_TYPE_P (base_return
) && CLASS_TYPE_P (over_return
))
2237 /* Strictly speaking, the standard requires the return type to be
2238 complete even if it only differs in cv-quals, but that seems
2239 like a bug in the wording. */
2240 if (!same_type_ignoring_top_level_qualifiers_p (base_return
,
2243 tree binfo
= lookup_base (over_return
, base_return
,
2244 ba_check
, NULL
, tf_none
);
2246 if (!binfo
|| binfo
== error_mark_node
)
2250 else if (can_convert_standard (TREE_TYPE (base_type
),
2251 TREE_TYPE (over_type
),
2252 tf_warning_or_error
))
2253 /* GNU extension, allow trivial pointer conversions such as
2254 converting to void *, or qualification conversion. */
2256 if (pedwarn (DECL_SOURCE_LOCATION (overrider
), 0,
2257 "invalid covariant return type for %q#D", overrider
))
2258 inform (DECL_SOURCE_LOCATION (basefn
),
2259 " overriding %q#D", basefn
);
2272 error ("invalid covariant return type for %q+#D", overrider
);
2273 error (" overriding %q+#D", basefn
);
2277 error ("conflicting return type specified for %q+#D", overrider
);
2278 error (" overriding %q+#D", basefn
);
2280 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2284 /* Check throw specifier is at least as strict. */
2285 maybe_instantiate_noexcept (basefn
);
2286 maybe_instantiate_noexcept (overrider
);
2287 base_throw
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (basefn
));
2288 over_throw
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (overrider
));
2290 if (!comp_except_specs (base_throw
, over_throw
, ce_derived
))
2292 error ("looser throw specifier for %q+#F", overrider
);
2293 error (" overriding %q+#F", basefn
);
2294 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2298 /* Check for conflicting type attributes. But leave transaction_safe for
2299 set_one_vmethod_tm_attributes. */
2300 if (!comp_type_attributes (over_type
, base_type
)
2301 && !tx_safe_fn_type_p (base_type
)
2302 && !tx_safe_fn_type_p (over_type
))
2304 error ("conflicting type attributes specified for %q+#D", overrider
);
2305 error (" overriding %q+#D", basefn
);
2306 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2310 /* A function declared transaction_safe_dynamic that overrides a function
2311 declared transaction_safe (but not transaction_safe_dynamic) is
2313 if (tx_safe_fn_type_p (base_type
)
2314 && lookup_attribute ("transaction_safe_dynamic",
2315 DECL_ATTRIBUTES (overrider
))
2316 && !lookup_attribute ("transaction_safe_dynamic",
2317 DECL_ATTRIBUTES (basefn
)))
2319 error_at (DECL_SOURCE_LOCATION (overrider
),
2320 "%qD declared %<transaction_safe_dynamic%>", overrider
);
2321 inform (DECL_SOURCE_LOCATION (basefn
),
2322 "overriding %qD declared %<transaction_safe%>", basefn
);
2325 if (DECL_DELETED_FN (basefn
) != DECL_DELETED_FN (overrider
))
2327 if (DECL_DELETED_FN (overrider
))
2329 error ("deleted function %q+D", overrider
);
2330 error ("overriding non-deleted function %q+D", basefn
);
2331 maybe_explain_implicit_delete (overrider
);
2335 error ("non-deleted function %q+D", overrider
);
2336 error ("overriding deleted function %q+D", basefn
);
2340 if (DECL_FINAL_P (basefn
))
2342 error ("virtual function %q+D", overrider
);
2343 error ("overriding final function %q+D", basefn
);
2349 /* Given a class TYPE, and a function decl FNDECL, look for
2350 virtual functions in TYPE's hierarchy which FNDECL overrides.
2351 We do not look in TYPE itself, only its bases.
2353 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
2354 find that it overrides anything.
2356 We check that every function which is overridden, is correctly
2360 look_for_overrides (tree type
, tree fndecl
)
2362 tree binfo
= TYPE_BINFO (type
);
2367 /* A constructor for a class T does not override a function T
2369 if (DECL_CONSTRUCTOR_P (fndecl
))
2372 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2374 tree basetype
= BINFO_TYPE (base_binfo
);
2376 if (TYPE_POLYMORPHIC_P (basetype
))
2377 found
+= look_for_overrides_r (basetype
, fndecl
);
2382 /* Look in TYPE for virtual functions with the same signature as
2386 look_for_overrides_here (tree type
, tree fndecl
)
2388 tree ovl
= lookup_fnfields_slot (type
, DECL_NAME (fndecl
));
2390 for (ovl_iterator
iter (ovl
); iter
; ++iter
)
2394 if (!DECL_VIRTUAL_P (fn
))
2395 /* Not a virtual. */;
2396 else if (DECL_CONTEXT (fn
) != type
)
2397 /* Introduced with a using declaration. */;
2398 else if (DECL_STATIC_FUNCTION_P (fndecl
))
2400 tree btypes
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2401 tree dtypes
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2402 if (compparms (TREE_CHAIN (btypes
), dtypes
))
2405 else if (same_signature_p (fndecl
, fn
))
2412 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
2413 TYPE itself and its bases. */
2416 look_for_overrides_r (tree type
, tree fndecl
)
2418 tree fn
= look_for_overrides_here (type
, fndecl
);
2421 if (DECL_STATIC_FUNCTION_P (fndecl
))
2423 /* A static member function cannot match an inherited
2424 virtual member function. */
2425 error ("%q+#D cannot be declared", fndecl
);
2426 error (" since %q+#D declared in base class", fn
);
2430 /* It's definitely virtual, even if not explicitly set. */
2431 DECL_VIRTUAL_P (fndecl
) = 1;
2432 check_final_overrider (fndecl
, fn
);
2437 /* We failed to find one declared in this class. Look in its bases. */
2438 return look_for_overrides (type
, fndecl
);
2441 /* Called via dfs_walk from dfs_get_pure_virtuals. */
2444 dfs_get_pure_virtuals (tree binfo
, void *data
)
2446 tree type
= (tree
) data
;
2448 /* We're not interested in primary base classes; the derived class
2449 of which they are a primary base will contain the information we
2451 if (!BINFO_PRIMARY_P (binfo
))
2455 for (virtuals
= BINFO_VIRTUALS (binfo
);
2457 virtuals
= TREE_CHAIN (virtuals
))
2458 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals
)))
2459 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (type
), BV_FN (virtuals
));
2465 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
2468 get_pure_virtuals (tree type
)
2470 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
2471 is going to be overridden. */
2472 CLASSTYPE_PURE_VIRTUALS (type
) = NULL
;
2473 /* Now, run through all the bases which are not primary bases, and
2474 collect the pure virtual functions. We look at the vtable in
2475 each class to determine what pure virtual functions are present.
2476 (A primary base is not interesting because the derived class of
2477 which it is a primary base will contain vtable entries for the
2478 pure virtuals in the base class. */
2479 dfs_walk_once (TYPE_BINFO (type
), NULL
, dfs_get_pure_virtuals
, type
);
2482 /* Debug info for C++ classes can get very large; try to avoid
2483 emitting it everywhere.
2485 Note that this optimization wins even when the target supports
2486 BINCL (if only slightly), and reduces the amount of work for the
2490 maybe_suppress_debug_info (tree t
)
2492 if (write_symbols
== NO_DEBUG
)
2495 /* We might have set this earlier in cp_finish_decl. */
2496 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 0;
2498 /* Always emit the information for each class every time. */
2499 if (flag_emit_class_debug_always
)
2502 /* If we already know how we're handling this class, handle debug info
2504 if (CLASSTYPE_INTERFACE_KNOWN (t
))
2506 if (CLASSTYPE_INTERFACE_ONLY (t
))
2507 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2508 /* else don't set it. */
2510 /* If the class has a vtable, write out the debug info along with
2512 else if (TYPE_CONTAINS_VPTR_P (t
))
2513 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2515 /* Otherwise, just emit the debug info normally. */
2518 /* Note that we want debugging information for a base class of a class
2519 whose vtable is being emitted. Normally, this would happen because
2520 calling the constructor for a derived class implies calling the
2521 constructors for all bases, which involve initializing the
2522 appropriate vptr with the vtable for the base class; but in the
2523 presence of optimization, this initialization may be optimized
2524 away, so we tell finish_vtable_vardecl that we want the debugging
2525 information anyway. */
2528 dfs_debug_mark (tree binfo
, void * /*data*/)
2530 tree t
= BINFO_TYPE (binfo
);
2532 if (CLASSTYPE_DEBUG_REQUESTED (t
))
2533 return dfs_skip_bases
;
2535 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
2540 /* Write out the debugging information for TYPE, whose vtable is being
2541 emitted. Also walk through our bases and note that we want to
2542 write out information for them. This avoids the problem of not
2543 writing any debug info for intermediate basetypes whose
2544 constructors, and thus the references to their vtables, and thus
2545 the vtables themselves, were optimized away. */
2548 note_debug_info_needed (tree type
)
2550 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
2552 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)) = 0;
2553 rest_of_type_compilation (type
, namespace_bindings_p ());
2556 dfs_walk_all (TYPE_BINFO (type
), dfs_debug_mark
, NULL
, 0);
2560 print_search_statistics (void)
2562 if (! GATHER_STATISTICS
)
2564 fprintf (stderr
, "no search statistics\n");
2568 fprintf (stderr
, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
2569 n_fields_searched
, n_calls_lookup_field
, n_calls_lookup_field_1
);
2570 fprintf (stderr
, "%d fnfields searched in %d calls to lookup_fnfields\n",
2571 n_outer_fields_searched
, n_calls_lookup_fnfields
);
2572 fprintf (stderr
, "%d calls to get_base_type\n", n_calls_get_base_type
);
2576 reinit_search_statistics (void)
2578 n_fields_searched
= 0;
2579 n_calls_lookup_field
= 0, n_calls_lookup_field_1
= 0;
2580 n_calls_lookup_fnfields
= 0, n_calls_lookup_fnfields_1
= 0;
2581 n_calls_get_base_type
= 0;
2582 n_outer_fields_searched
= 0;
2583 n_contexts_saved
= 0;
2586 /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2587 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2588 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2589 bases have been encountered already in the tree walk. PARENT_CONVS
2590 is the list of lists of conversion functions that could hide CONV
2591 and OTHER_CONVS is the list of lists of conversion functions that
2592 could hide or be hidden by CONV, should virtualness be involved in
2593 the hierarchy. Merely checking the conversion op's name is not
2594 enough because two conversion operators to the same type can have
2595 different names. Return nonzero if we are visible. */
2598 check_hidden_convs (tree binfo
, int virtual_depth
, int virtualness
,
2599 tree to_type
, tree parent_convs
, tree other_convs
)
2603 /* See if we are hidden by a parent conversion. */
2604 for (level
= parent_convs
; level
; level
= TREE_CHAIN (level
))
2605 for (probe
= TREE_VALUE (level
); probe
; probe
= TREE_CHAIN (probe
))
2606 if (same_type_p (to_type
, TREE_TYPE (probe
)))
2609 if (virtual_depth
|| virtualness
)
2611 /* In a virtual hierarchy, we could be hidden, or could hide a
2612 conversion function on the other_convs list. */
2613 for (level
= other_convs
; level
; level
= TREE_CHAIN (level
))
2619 if (!(virtual_depth
|| TREE_STATIC (level
)))
2620 /* Neither is morally virtual, so cannot hide each other. */
2623 if (!TREE_VALUE (level
))
2624 /* They evaporated away already. */
2627 they_hide_us
= (virtual_depth
2628 && original_binfo (binfo
, TREE_PURPOSE (level
)));
2629 we_hide_them
= (!they_hide_us
&& TREE_STATIC (level
)
2630 && original_binfo (TREE_PURPOSE (level
), binfo
));
2632 if (!(we_hide_them
|| they_hide_us
))
2633 /* Neither is within the other, so no hiding can occur. */
2636 for (prev
= &TREE_VALUE (level
), other
= *prev
; other
;)
2638 if (same_type_p (to_type
, TREE_TYPE (other
)))
2641 /* We are hidden. */
2646 /* We hide the other one. */
2647 other
= TREE_CHAIN (other
);
2652 prev
= &TREE_CHAIN (other
);
2660 /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2661 of conversion functions, the first slot will be for the current
2662 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2663 of conversion functions from children of the current binfo,
2664 concatenated with conversions from elsewhere in the hierarchy --
2665 that list begins with OTHER_CONVS. Return a single list of lists
2666 containing only conversions from the current binfo and its
2670 split_conversions (tree my_convs
, tree parent_convs
,
2671 tree child_convs
, tree other_convs
)
2676 /* Remove the original other_convs portion from child_convs. */
2677 for (prev
= NULL
, t
= child_convs
;
2678 t
!= other_convs
; prev
= t
, t
= TREE_CHAIN (t
))
2682 TREE_CHAIN (prev
) = NULL_TREE
;
2684 child_convs
= NULL_TREE
;
2686 /* Attach the child convs to any we had at this level. */
2689 my_convs
= parent_convs
;
2690 TREE_CHAIN (my_convs
) = child_convs
;
2693 my_convs
= child_convs
;
2698 /* Worker for lookup_conversions. Lookup conversion functions in
2699 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in
2700 a morally virtual base, and VIRTUALNESS is nonzero, if we've
2701 encountered virtual bases already in the tree walk. PARENT_CONVS &
2702 PARENT_TPL_CONVS are lists of list of conversions within parent
2703 binfos. OTHER_CONVS and OTHER_TPL_CONVS are conversions found
2704 elsewhere in the tree. Return the conversions found within this
2705 portion of the graph in CONVS and TPL_CONVS. Return nonzero is we
2706 encountered virtualness. We keep template and non-template
2707 conversions separate, to avoid unnecessary type comparisons.
2709 The located conversion functions are held in lists of lists. The
2710 TREE_VALUE of the outer list is the list of conversion functions
2711 found in a particular binfo. The TREE_PURPOSE of both the outer
2712 and inner lists is the binfo at which those conversions were
2713 found. TREE_STATIC is set for those lists within of morally
2714 virtual binfos. The TREE_VALUE of the inner list is the conversion
2715 function or overload itself. The TREE_TYPE of each inner list node
2716 is the converted-to type. */
2719 lookup_conversions_r (tree binfo
,
2720 int virtual_depth
, int virtualness
,
2721 tree parent_convs
, tree parent_tpl_convs
,
2722 tree other_convs
, tree other_tpl_convs
,
2723 tree
*convs
, tree
*tpl_convs
)
2725 int my_virtualness
= 0;
2726 tree my_convs
= NULL_TREE
;
2727 tree my_tpl_convs
= NULL_TREE
;
2728 tree child_convs
= NULL_TREE
;
2729 tree child_tpl_convs
= NULL_TREE
;
2732 vec
<tree
, va_gc
> *method_vec
= CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo
));
2735 /* If we have no conversion operators, then don't look. */
2736 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo
)))
2738 *convs
= *tpl_convs
= NULL_TREE
;
2743 if (BINFO_VIRTUAL_P (binfo
))
2746 /* First, locate the unhidden ones at this level. */
2747 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2748 vec_safe_iterate (method_vec
, i
, &conv
);
2751 tree cur
= OVL_FIRST (conv
);
2753 if (!DECL_CONV_FN_P (cur
))
2756 if (TREE_CODE (cur
) == TEMPLATE_DECL
)
2757 /* Only template conversions can be overloaded, and we must
2758 flatten them out and check each one individually. */
2759 for (ovl_iterator
iter (conv
); iter
; ++iter
)
2762 tree type
= DECL_CONV_FN_TYPE (tpl
);
2764 if (check_hidden_convs (binfo
, virtual_depth
, virtualness
,
2765 type
, parent_tpl_convs
, other_tpl_convs
))
2767 my_tpl_convs
= tree_cons (binfo
, tpl
, my_tpl_convs
);
2768 TREE_TYPE (my_tpl_convs
) = type
;
2771 TREE_STATIC (my_tpl_convs
) = 1;
2778 tree name
= DECL_NAME (cur
);
2780 if (!IDENTIFIER_MARKED (name
))
2782 tree type
= DECL_CONV_FN_TYPE (cur
);
2783 if (type_uses_auto (type
))
2786 type
= DECL_CONV_FN_TYPE (cur
);
2789 if (check_hidden_convs (binfo
, virtual_depth
, virtualness
,
2790 type
, parent_convs
, other_convs
))
2792 my_convs
= tree_cons (binfo
, conv
, my_convs
);
2793 TREE_TYPE (my_convs
) = type
;
2796 TREE_STATIC (my_convs
) = 1;
2799 IDENTIFIER_MARKED (name
) = 1;
2807 parent_convs
= tree_cons (binfo
, my_convs
, parent_convs
);
2809 TREE_STATIC (parent_convs
) = 1;
2814 parent_tpl_convs
= tree_cons (binfo
, my_tpl_convs
, parent_tpl_convs
);
2816 TREE_STATIC (parent_tpl_convs
) = 1;
2819 child_convs
= other_convs
;
2820 child_tpl_convs
= other_tpl_convs
;
2822 /* Now iterate over each base, looking for more conversions. */
2823 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2825 tree base_convs
, base_tpl_convs
;
2826 unsigned base_virtualness
;
2828 base_virtualness
= lookup_conversions_r (base_binfo
,
2829 virtual_depth
, virtualness
,
2830 parent_convs
, parent_tpl_convs
,
2831 child_convs
, child_tpl_convs
,
2832 &base_convs
, &base_tpl_convs
);
2833 if (base_virtualness
)
2834 my_virtualness
= virtualness
= 1;
2835 child_convs
= chainon (base_convs
, child_convs
);
2836 child_tpl_convs
= chainon (base_tpl_convs
, child_tpl_convs
);
2839 /* Unmark the conversions found at this level */
2840 for (conv
= my_convs
; conv
; conv
= TREE_CHAIN (conv
))
2841 IDENTIFIER_MARKED (OVL_NAME (TREE_VALUE (conv
))) = 0;
2843 *convs
= split_conversions (my_convs
, parent_convs
,
2844 child_convs
, other_convs
);
2845 *tpl_convs
= split_conversions (my_tpl_convs
, parent_tpl_convs
,
2846 child_tpl_convs
, other_tpl_convs
);
2848 return my_virtualness
;
2851 /* Return a TREE_LIST containing all the non-hidden user-defined
2852 conversion functions for TYPE (and its base-classes). The
2853 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2854 function. The TREE_PURPOSE is the BINFO from which the conversion
2855 functions in this node were selected. This function is effectively
2856 performing a set of member lookups as lookup_fnfield does, but
2857 using the type being converted to as the unique key, rather than the
2861 lookup_conversions (tree type
)
2863 tree convs
, tpl_convs
;
2864 tree list
= NULL_TREE
;
2866 complete_type (type
);
2867 if (!CLASS_TYPE_P (type
) || !TYPE_BINFO (type
))
2870 lookup_conversions_r (TYPE_BINFO (type
), 0, 0,
2871 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
2872 &convs
, &tpl_convs
);
2874 /* Flatten the list-of-lists */
2875 for (; convs
; convs
= TREE_CHAIN (convs
))
2879 for (probe
= TREE_VALUE (convs
); probe
; probe
= next
)
2881 next
= TREE_CHAIN (probe
);
2883 TREE_CHAIN (probe
) = list
;
2888 for (; tpl_convs
; tpl_convs
= TREE_CHAIN (tpl_convs
))
2892 for (probe
= TREE_VALUE (tpl_convs
); probe
; probe
= next
)
2894 next
= TREE_CHAIN (probe
);
2896 TREE_CHAIN (probe
) = list
;
2904 /* Returns the binfo of the first direct or indirect virtual base derived
2905 from BINFO, or NULL if binfo is not via virtual. */
2908 binfo_from_vbase (tree binfo
)
2910 for (; binfo
; binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2912 if (BINFO_VIRTUAL_P (binfo
))
2918 /* Returns the binfo of the first direct or indirect virtual base derived
2919 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2923 binfo_via_virtual (tree binfo
, tree limit
)
2925 if (limit
&& !CLASSTYPE_VBASECLASSES (limit
))
2926 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2929 for (; binfo
&& !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), limit
);
2930 binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2932 if (BINFO_VIRTUAL_P (binfo
))
2938 /* BINFO is for a base class in some hierarchy. Return true iff it is a
2942 binfo_direct_p (tree binfo
)
2944 tree d_binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
2945 if (BINFO_INHERITANCE_CHAIN (d_binfo
))
2946 /* A second inheritance chain means indirect. */
2948 if (!BINFO_VIRTUAL_P (binfo
))
2949 /* Non-virtual, so only one inheritance chain means direct. */
2951 /* A virtual base looks like a direct base, so we need to look through the
2952 direct bases to see if it's there. */
2954 for (int i
= 0; BINFO_BASE_ITERATE (d_binfo
, i
, b_binfo
); ++i
)
2955 if (b_binfo
== binfo
)
2960 /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2961 Find the equivalent binfo within whatever graph HERE is located.
2962 This is the inverse of original_binfo. */
2965 copied_binfo (tree binfo
, tree here
)
2967 tree result
= NULL_TREE
;
2969 if (BINFO_VIRTUAL_P (binfo
))
2973 for (t
= here
; BINFO_INHERITANCE_CHAIN (t
);
2974 t
= BINFO_INHERITANCE_CHAIN (t
))
2977 result
= binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (t
));
2979 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2985 cbinfo
= copied_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2986 for (ix
= 0; BINFO_BASE_ITERATE (cbinfo
, ix
, base_binfo
); ix
++)
2987 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
), BINFO_TYPE (binfo
)))
2989 result
= base_binfo
;
2995 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here
), BINFO_TYPE (binfo
)));
2999 gcc_assert (result
);
3004 binfo_for_vbase (tree base
, tree t
)
3008 vec
<tree
, va_gc
> *vbases
;
3010 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
3011 vec_safe_iterate (vbases
, ix
, &binfo
); ix
++)
3012 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), base
))
3017 /* BINFO is some base binfo of HERE, within some other
3018 hierarchy. Return the equivalent binfo, but in the hierarchy
3019 dominated by HERE. This is the inverse of copied_binfo. If BINFO
3020 is not a base binfo of HERE, returns NULL_TREE. */
3023 original_binfo (tree binfo
, tree here
)
3027 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (here
)))
3029 else if (BINFO_VIRTUAL_P (binfo
))
3030 result
= (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here
))
3031 ? binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (here
))
3033 else if (BINFO_INHERITANCE_CHAIN (binfo
))
3037 base_binfos
= original_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
3043 for (ix
= 0; (base_binfo
= BINFO_BASE_BINFO (base_binfos
, ix
)); ix
++)
3044 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
3045 BINFO_TYPE (binfo
)))
3047 result
= base_binfo
;
3056 /* True iff TYPE has any dependent bases (and therefore we can't say
3057 definitively that another class is not a base of an instantiation of
3061 any_dependent_bases_p (tree type
)
3063 if (!type
|| !CLASS_TYPE_P (type
) || !processing_template_decl
)
3068 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_BINFOS (TYPE_BINFO (type
)), i
, base_binfo
)
3069 if (BINFO_DEPENDENT_BASE_P (base_binfo
))