1 /* Breadth-first and depth-first routines for
2 searching multiple-inheritance lattice for GNU C++.
3 Copyright (C) 1987-2023 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"
31 #include "stringpool.h"
33 #include "tree-inline.h"
35 static int is_subobject_of_p (tree
, tree
);
36 static tree
dfs_lookup_base (tree
, void *);
37 static tree
dfs_dcast_hint_pre (tree
, void *);
38 static tree
dfs_dcast_hint_post (tree
, void *);
39 static tree
dfs_debug_mark (tree
, void *);
40 static int check_hidden_convs (tree
, int, int, tree
, tree
, tree
);
41 static tree
split_conversions (tree
, tree
, tree
, tree
);
42 static int lookup_conversions_r (tree
, int, int, tree
, tree
, tree
*);
43 static int look_for_overrides_r (tree
, tree
);
44 static tree
lookup_field_r (tree
, void *);
45 static tree
dfs_accessible_post (tree
, void *);
46 static tree
dfs_walk_once_accessible (tree
, bool,
47 tree (*pre_fn
) (tree
, void *),
48 tree (*post_fn
) (tree
, void *),
50 static tree
dfs_access_in_type (tree
, void *);
51 static access_kind
access_in_type (tree
, tree
);
52 static tree
dfs_get_pure_virtuals (tree
, void *);
55 /* Data for lookup_base and its workers. */
57 struct lookup_base_data_s
59 HOST_WIDE_INT offset
; /* Offset we want, or -1 if any. */
60 tree t
; /* type being searched. */
61 tree base
; /* The base type we're looking for. */
62 tree binfo
; /* Found binfo. */
63 bool via_virtual
; /* Found via a virtual path. */
64 bool ambiguous
; /* Found multiply ambiguous */
65 bool repeated_base
; /* Whether there are repeated bases in the
67 bool want_any
; /* Whether we want any matching binfo. */
70 /* Worker function for lookup_base. See if we've found the desired
71 base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
74 dfs_lookup_base (tree binfo
, void *data_
)
76 struct lookup_base_data_s
*data
= (struct lookup_base_data_s
*) data_
;
78 if (data
->offset
!= -1)
80 /* We're looking for the type at a particular offset. */
81 int comp
= compare_tree_int (BINFO_OFFSET (binfo
), data
->offset
);
83 /* Don't bother looking into bases laid out later; even if they
84 do virtually inherit from the base we want, we can get there
86 return dfs_skip_bases
;
88 && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->base
))
89 /* Right type, wrong offset. */
90 return dfs_skip_bases
;
94 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->base
))
100 = binfo_via_virtual (data
->binfo
, data
->t
) != NULL_TREE
;
102 if (!data
->repeated_base
)
103 /* If there are no repeated bases, we can stop now. */
106 if (data
->want_any
&& !data
->via_virtual
)
107 /* If this is a non-virtual base, then we can't do
111 return dfs_skip_bases
;
115 gcc_assert (binfo
!= data
->binfo
);
117 /* We've found more than one matching binfo. */
120 /* This is immediately ambiguous. */
121 data
->binfo
= NULL_TREE
;
122 data
->ambiguous
= true;
123 return error_mark_node
;
126 /* Prefer one via a non-virtual path. */
127 if (!binfo_via_virtual (binfo
, data
->t
))
130 data
->via_virtual
= false;
134 /* There must be repeated bases, otherwise we'd have stopped
135 on the first base we found. */
136 return dfs_skip_bases
;
143 /* This deals with bug PR17314.
145 DECL is a declaration and BINFO represents a class that has attempted (but
146 failed) to access DECL.
148 Examine the parent binfos of BINFO and determine whether any of them had
149 private access to DECL. If they did, return the parent binfo. This helps
150 in figuring out the correct error message to show (if the parents had
151 access, it's their fault for not giving sufficient access to BINFO).
153 If no parents had access, return NULL_TREE. */
156 get_parent_with_private_access (tree decl
, tree binfo
)
158 /* Only BINFOs should come through here. */
159 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
161 tree base_binfo
= NULL_TREE
;
163 /* Iterate through immediate parent classes. */
164 for (int i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
166 /* This parent had private access. Therefore that's why BINFO can't
168 if (access_in_type (BINFO_TYPE (base_binfo
), decl
) == ak_private
)
172 /* None of the parents had access. Note: it's impossible for one of the
173 parents to have had public or protected access to DECL, since then
174 BINFO would have been able to access DECL too. */
178 /* Returns true if type BASE is accessible in T. (BASE is known to be
179 a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
180 true, consider any special access of the current scope, or access
181 bestowed by friendship. */
184 accessible_base_p (tree t
, tree base
, bool consider_local_p
)
188 /* [class.access.base]
190 A base class is said to be accessible if an invented public
191 member of the base class is accessible.
193 If BASE is a non-proper base, this condition is trivially
195 if (same_type_p (t
, base
))
197 /* Rather than inventing a public member, we use the implicit
198 public typedef created in the scope of every class. */
199 decl
= TYPE_FIELDS (base
);
200 while (!DECL_SELF_REFERENCE_P (decl
))
201 decl
= DECL_CHAIN (decl
);
202 while (ANON_AGGR_TYPE_P (t
))
203 t
= TYPE_CONTEXT (t
);
204 return accessible_p (t
, decl
, consider_local_p
);
207 /* Lookup BASE in the hierarchy dominated by T. Do access checking as
208 ACCESS specifies. Return the binfo we discover. If KIND_PTR is
209 non-NULL, fill with information about what kind of base we
210 discovered. If OFFSET is other than -1, only match at that offset.
212 If the base is inaccessible, or ambiguous, then error_mark_node is
213 returned. If the tf_error bit of COMPLAIN is not set, no error
217 lookup_base (tree t
, tree base
, base_access access
,
218 base_kind
*kind_ptr
, tsubst_flags_t complain
,
219 HOST_WIDE_INT offset
/* = -1 */)
225 /* "Nothing" is definitely not derived from Base. */
229 *kind_ptr
= bk_not_base
;
233 if (t
== error_mark_node
|| base
== error_mark_node
)
236 *kind_ptr
= bk_not_base
;
237 return error_mark_node
;
239 gcc_assert (TYPE_P (base
));
248 t
= complete_type (TYPE_MAIN_VARIANT (t
));
249 if (dependent_type_p (t
))
250 if (tree open
= currently_open_class (t
))
252 t_binfo
= TYPE_BINFO (t
);
255 base
= TYPE_MAIN_VARIANT (base
);
257 /* If BASE is incomplete, it can't be a base of T--and instantiating it
258 might cause an error. */
259 if (t_binfo
&& CLASS_TYPE_P (base
) && COMPLETE_OR_OPEN_TYPE_P (base
))
261 struct lookup_base_data_s data
;
265 data
.binfo
= NULL_TREE
;
266 data
.ambiguous
= data
.via_virtual
= false;
267 data
.repeated_base
= (offset
== -1) && CLASSTYPE_REPEATED_BASE_P (t
);
268 data
.want_any
= access
== ba_any
;
269 data
.offset
= offset
;
271 dfs_walk_once (t_binfo
, dfs_lookup_base
, NULL
, &data
);
275 bk
= data
.ambiguous
? bk_ambig
: bk_not_base
;
276 else if (binfo
== t_binfo
)
278 else if (data
.via_virtual
)
289 /* Check that the base is unambiguous and accessible. */
290 if (access
!= ba_any
)
297 if (complain
& tf_error
)
298 error ("%qT is an ambiguous base of %qT", base
, t
);
299 binfo
= error_mark_node
;
303 if ((access
& ba_check_bit
)
304 /* If BASE is incomplete, then BASE and TYPE are probably
305 the same, in which case BASE is accessible. If they
306 are not the same, then TYPE is invalid. In that case,
307 there's no need to issue another error here, and
308 there's no implicit typedef to use in the code that
309 follows, so we skip the check. */
310 && COMPLETE_TYPE_P (base
)
311 && !accessible_base_p (t
, base
, !(access
& ba_ignore_scope
)))
313 if (complain
& tf_error
)
314 error ("%qT is an inaccessible base of %qT", base
, t
);
315 binfo
= error_mark_node
;
316 bk
= bk_inaccessible
;
327 /* Data for dcast_base_hint walker. */
331 tree subtype
; /* The base type we're looking for. */
332 int virt_depth
; /* Number of virtual bases encountered from most
334 tree offset
; /* Best hint offset discovered so far. */
335 bool repeated_base
; /* Whether there are repeated bases in the
339 /* Worker for dcast_base_hint. Search for the base type being cast
343 dfs_dcast_hint_pre (tree binfo
, void *data_
)
345 struct dcast_data_s
*data
= (struct dcast_data_s
*) data_
;
347 if (BINFO_VIRTUAL_P (binfo
))
350 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->subtype
))
352 if (data
->virt_depth
)
354 data
->offset
= ssize_int (-1);
358 data
->offset
= ssize_int (-3);
360 data
->offset
= BINFO_OFFSET (binfo
);
362 return data
->repeated_base
? dfs_skip_bases
: data
->offset
;
368 /* Worker for dcast_base_hint. Track the virtual depth. */
371 dfs_dcast_hint_post (tree binfo
, void *data_
)
373 struct dcast_data_s
*data
= (struct dcast_data_s
*) data_
;
375 if (BINFO_VIRTUAL_P (binfo
))
381 /* The dynamic cast runtime needs a hint about how the static SUBTYPE type
382 started from is related to the required TARGET type, in order to optimize
383 the inheritance graph search. This information is independent of the
384 current context, and ignores private paths, hence get_base_distance is
385 inappropriate. Return a TREE specifying the base offset, BOFF.
386 BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
387 and there are no public virtual SUBTYPE bases.
388 BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
389 BOFF == -2, SUBTYPE is not a public base.
390 BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
393 dcast_base_hint (tree subtype
, tree target
)
395 struct dcast_data_s data
;
397 data
.subtype
= subtype
;
399 data
.offset
= NULL_TREE
;
400 data
.repeated_base
= CLASSTYPE_REPEATED_BASE_P (target
);
402 dfs_walk_once_accessible (TYPE_BINFO (target
), /*friends=*/false,
403 dfs_dcast_hint_pre
, dfs_dcast_hint_post
, &data
);
404 return data
.offset
? data
.offset
: ssize_int (-2);
407 /* Search for a member with name NAME in a multiple inheritance
408 lattice specified by TYPE. If it does not exist, return NULL_TREE.
409 If the member is ambiguously referenced, return `error_mark_node'.
410 Otherwise, return a DECL with the indicated name. If WANT_TYPE is
411 true, type declarations are preferred. */
413 /* Return the FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, or
414 NAMESPACE_DECL corresponding to the innermost non-block scope. */
419 /* There are a number of cases we need to be aware of here:
420 current_class_type current_function_decl
427 Those last two make life interesting. If we're in a function which is
428 itself inside a class, we need decls to go into the fn's decls (our
429 second case below). But if we're in a class and the class itself is
430 inside a function, we need decls to go into the decls for the class. To
431 achieve this last goal, we must see if, when both current_class_ptr and
432 current_function_decl are set, the class was declared inside that
433 function. If so, we know to put the decls into the class's scope. */
434 if (current_function_decl
&& current_class_type
435 && ((DECL_FUNCTION_MEMBER_P (current_function_decl
)
436 && same_type_p (DECL_CONTEXT (current_function_decl
),
438 || (DECL_FRIEND_CONTEXT (current_function_decl
)
439 && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl
),
440 current_class_type
))))
441 return current_function_decl
;
443 if (current_class_type
)
444 return current_class_type
;
446 if (current_function_decl
)
447 return current_function_decl
;
449 return current_namespace
;
452 /* Returns nonzero if we are currently in a function scope. Note
453 that this function returns zero if we are within a local class, but
454 not within a member function body of the local class. */
457 at_function_scope_p (void)
459 tree cs
= current_scope ();
460 /* Also check cfun to make sure that we're really compiling
461 this function (as opposed to having set current_function_decl
462 for access checking or some such). */
463 return (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
464 && cfun
&& cfun
->decl
== current_function_decl
);
467 /* Returns true if the innermost active scope is a class scope. */
470 at_class_scope_p (void)
472 tree cs
= current_scope ();
473 return cs
&& TYPE_P (cs
);
476 /* Returns true if the innermost active scope is a namespace scope. */
479 at_namespace_scope_p (void)
481 tree cs
= current_scope ();
482 return cs
&& TREE_CODE (cs
) == NAMESPACE_DECL
;
485 /* Return the scope of DECL, as appropriate when doing name-lookup. */
488 context_for_name_lookup (tree decl
)
492 For the purposes of name lookup, after the anonymous union
493 definition, the members of the anonymous union are considered to
494 have been defined in the scope in which the anonymous union is
496 tree context
= DECL_CONTEXT (decl
);
498 while (context
&& TYPE_P (context
)
499 && (ANON_AGGR_TYPE_P (context
) || UNSCOPED_ENUM_P (context
)))
500 context
= TYPE_CONTEXT (context
);
502 context
= global_namespace
;
507 /* Like the above, but always return a type, because it's simpler for member
508 handling to refer to the anonymous aggr rather than a function. */
511 type_context_for_name_lookup (tree decl
)
513 tree context
= DECL_P (decl
) ? DECL_CONTEXT (decl
) : decl
;
514 gcc_checking_assert (CLASS_TYPE_P (context
));
516 while (context
&& TYPE_P (context
) && ANON_AGGR_TYPE_P (context
))
518 tree next
= TYPE_CONTEXT (context
);
526 /* Returns true iff DECL is declared in TYPE. */
529 member_declared_in_type (tree decl
, tree type
)
531 /* A normal declaration obviously counts. */
532 if (context_for_name_lookup (decl
) == type
)
534 /* So does a using or access declaration. */
535 if (DECL_LANG_SPECIFIC (decl
) && !DECL_DISCRIMINATOR_P (decl
)
536 && purpose_member (type
, DECL_ACCESS (decl
)))
541 /* The accessibility routines use BINFO_ACCESS for scratch space
542 during the computation of the accessibility of some declaration. */
544 /* Avoid walking up past a declaration of the member. */
547 dfs_access_in_type_pre (tree binfo
, void *data
)
549 tree decl
= (tree
) data
;
550 tree type
= BINFO_TYPE (binfo
);
551 if (member_declared_in_type (decl
, type
))
552 return dfs_skip_bases
;
556 #define BINFO_ACCESS(NODE) \
557 ((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE)))
559 /* Set the access associated with NODE to ACCESS. */
561 #define SET_BINFO_ACCESS(NODE, ACCESS) \
562 ((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \
563 (TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0))
565 /* Called from access_in_type via dfs_walk. Calculate the access to
566 DATA (which is really a DECL) in BINFO. */
569 dfs_access_in_type (tree binfo
, void *data
)
571 tree decl
= (tree
) data
;
572 tree type
= BINFO_TYPE (binfo
);
573 access_kind access
= ak_none
;
575 if (context_for_name_lookup (decl
) == type
)
577 /* If we have descended to the scope of DECL, just note the
578 appropriate access. */
579 if (TREE_PRIVATE (decl
))
581 else if (TREE_PROTECTED (decl
))
582 access
= ak_protected
;
588 /* First, check for an access-declaration that gives us more
589 access to the DECL. */
590 if (DECL_LANG_SPECIFIC (decl
) && !DECL_DISCRIMINATOR_P (decl
))
592 tree decl_access
= purpose_member (type
, DECL_ACCESS (decl
));
596 decl_access
= TREE_VALUE (decl_access
);
598 if (decl_access
== access_public_node
)
600 else if (decl_access
== access_protected_node
)
601 access
= ak_protected
;
602 else if (decl_access
== access_private_node
)
613 vec
<tree
, va_gc
> *accesses
;
615 /* Otherwise, scan our baseclasses, and pick the most favorable
617 accesses
= BINFO_BASE_ACCESSES (binfo
);
618 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
620 tree base_access
= (*accesses
)[i
];
621 access_kind base_access_now
= BINFO_ACCESS (base_binfo
);
623 if (base_access_now
== ak_none
|| base_access_now
== ak_private
)
624 /* If it was not accessible in the base, or only
625 accessible as a private member, we can't access it
627 base_access_now
= ak_none
;
628 else if (base_access
== access_protected_node
)
629 /* Public and protected members in the base become
631 base_access_now
= ak_protected
;
632 else if (base_access
== access_private_node
)
633 /* Public and protected members in the base become
635 base_access_now
= ak_private
;
637 /* See if the new access, via this base, gives more
638 access than our previous best access. */
639 if (base_access_now
!= ak_none
640 && (access
== ak_none
|| base_access_now
< access
))
642 access
= base_access_now
;
644 /* If the new access is public, we can't do better. */
645 if (access
== ak_public
)
652 /* Note the access to DECL in TYPE. */
653 SET_BINFO_ACCESS (binfo
, access
);
658 /* Return the access to DECL in TYPE. */
661 access_in_type (tree type
, tree decl
)
663 tree binfo
= TYPE_BINFO (type
);
665 /* We must take into account
669 If a name can be reached by several paths through a multiple
670 inheritance graph, the access is that of the path that gives
673 The algorithm we use is to make a post-order depth-first traversal
674 of the base-class hierarchy. As we come up the tree, we annotate
675 each node with the most lenient access. */
676 dfs_walk_once (binfo
, dfs_access_in_type_pre
, dfs_access_in_type
, decl
);
678 return BINFO_ACCESS (binfo
);
681 /* Returns nonzero if it is OK to access DECL named in TYPE through an object
682 of OTYPE in the context of DERIVED. */
685 protected_accessible_p (tree decl
, tree derived
, tree type
, tree otype
)
687 /* We're checking this clause from [class.access.base]
689 m as a member of N is protected, and the reference occurs in a
690 member or friend of class N, or in a member or friend of a
691 class P derived from N, where m as a member of P is public, private
694 Here DERIVED is a possible P, DECL is m and TYPE is N. */
696 /* If DERIVED isn't derived from N, then it can't be a P. */
697 if (!DERIVED_FROM_P (type
, derived
))
700 /* DECL_NONSTATIC_MEMBER_P won't work for USING_DECLs. */
701 decl
= strip_using_decl (decl
);
702 /* We don't expect or support dependent decls. */
703 gcc_assert (TREE_CODE (decl
) != USING_DECL
);
707 When a friend or a member function of a derived class references
708 a protected non-static member of a base class, an access check
709 applies in addition to those described earlier in clause
710 _class.access_) Except when forming a pointer to member
711 (_expr.unary.op_), the access must be through a pointer to,
712 reference to, or object of the derived class itself (or any class
713 derived from that class) (_expr.ref_). If the access is to form
714 a pointer to member, the nested-name-specifier shall name the
715 derived class (or any class derived from that class). */
716 if (DECL_NONSTATIC_MEMBER_P (decl
)
717 && !DERIVED_FROM_P (derived
, otype
))
723 /* Returns nonzero if SCOPE is a type or a friend of a type which would be able
724 to access DECL through TYPE. OTYPE is the type of the object. */
727 friend_accessible_p (tree scope
, tree decl
, tree type
, tree otype
)
729 /* We're checking this clause from [class.access.base]
731 m as a member of N is protected, and the reference occurs in a
732 member or friend of class N, or in a member or friend of a
733 class P derived from N, where m as a member of P is public, private
736 Here DECL is m and TYPE is N. SCOPE is the current context,
737 and we check all its possible Ps. */
738 tree befriending_classes
;
744 if (is_global_friend (scope
))
747 /* Is SCOPE itself a suitable P? */
748 if (TYPE_P (scope
) && protected_accessible_p (decl
, scope
, type
, otype
))
751 if (DECL_DECLARES_FUNCTION_P (scope
))
752 befriending_classes
= DECL_BEFRIENDING_CLASSES (scope
);
753 else if (TYPE_P (scope
))
754 befriending_classes
= CLASSTYPE_BEFRIENDING_CLASSES (scope
);
758 for (t
= befriending_classes
; t
; t
= TREE_CHAIN (t
))
759 if (protected_accessible_p (decl
, TREE_VALUE (t
), type
, otype
))
762 /* Nested classes have the same access as their enclosing types, as
763 per DR 45 (this is a change from C++98). */
765 if (friend_accessible_p (TYPE_CONTEXT (scope
), decl
, type
, otype
))
768 if (DECL_DECLARES_FUNCTION_P (scope
))
770 /* Perhaps this SCOPE is a member of a class which is a
772 if (DECL_CLASS_SCOPE_P (scope
)
773 && friend_accessible_p (DECL_CONTEXT (scope
), decl
, type
, otype
))
775 /* Perhaps SCOPE is a friend function defined inside a class from which
776 DECL is accessible. */
777 if (tree fctx
= DECL_FRIEND_CONTEXT (scope
))
778 if (friend_accessible_p (fctx
, decl
, type
, otype
))
782 /* Maybe scope's template is a friend. */
783 if (tree tinfo
= get_template_info (scope
))
785 tree tmpl
= TI_TEMPLATE (tinfo
);
786 if (DECL_CLASS_TEMPLATE_P (tmpl
))
787 tmpl
= TREE_TYPE (tmpl
);
789 tmpl
= DECL_TEMPLATE_RESULT (tmpl
);
792 /* Increment processing_template_decl to make sure that
793 dependent_type_p works correctly. */
794 ++processing_template_decl
;
795 int ret
= friend_accessible_p (tmpl
, decl
, type
, otype
);
796 --processing_template_decl
;
802 /* If is_friend is true, we should have found a befriending class. */
803 gcc_checking_assert (!is_friend (type
, scope
));
808 struct dfs_accessible_data
814 /* Avoid walking up past a declaration of the member. */
817 dfs_accessible_pre (tree binfo
, void *data
)
819 dfs_accessible_data
*d
= (dfs_accessible_data
*)data
;
820 tree type
= BINFO_TYPE (binfo
);
821 if (member_declared_in_type (d
->decl
, type
))
822 return dfs_skip_bases
;
826 /* Called via dfs_walk_once_accessible from accessible_p */
829 dfs_accessible_post (tree binfo
, void *data
)
831 /* access_in_type already set BINFO_ACCESS for us. */
832 access_kind access
= BINFO_ACCESS (binfo
);
833 tree N
= BINFO_TYPE (binfo
);
834 dfs_accessible_data
*d
= (dfs_accessible_data
*)data
;
836 tree scope
= current_nonlambda_scope ();
838 /* A member m is accessible at the point R when named in class N if */
845 /* m as a member of N is public, or */
850 /* m as a member of N is private, and R occurs in a member or friend of
852 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
853 && is_friend (N
, scope
))
860 /* m as a member of N is protected, and R occurs in a member or friend
861 of class N, or in a member or friend of a class P derived from N,
862 where m as a member of P is public, private, or protected */
863 if (friend_accessible_p (scope
, decl
, N
, d
->object_type
))
873 /* Like accessible_p below, but within a template returns true iff DECL is
874 accessible in TYPE to all possible instantiations of the template. */
877 accessible_in_template_p (tree type
, tree decl
)
879 int save_ptd
= processing_template_decl
;
880 processing_template_decl
= 0;
881 int val
= accessible_p (type
, decl
, false);
882 processing_template_decl
= save_ptd
;
886 /* DECL is a declaration from a base class of TYPE, which was the
887 class used to name DECL. Return nonzero if, in the current
888 context, DECL is accessible. If TYPE is actually a BINFO node,
889 then we can tell in what context the access is occurring by looking
890 at the most derived class along the path indicated by BINFO. If
891 CONSIDER_LOCAL is true, do consider special access the current
892 scope or friendship thereof we might have. */
895 accessible_p (tree type
, tree decl
, bool consider_local_p
)
900 /* If this declaration is in a block or namespace scope, there's no
902 if (!TYPE_P (context_for_name_lookup (decl
)))
905 /* There is no need to perform access checks inside a thunk. */
906 if (current_function_decl
&& DECL_THUNK_P (current_function_decl
))
909 tree otype
= NULL_TREE
;
912 /* When accessing a non-static member, the most derived type in the
913 binfo chain is the type of the object; remember that type for
914 protected_accessible_p. */
915 for (tree b
= type
; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
916 otype
= BINFO_TYPE (b
);
917 type
= BINFO_TYPE (type
);
922 /* Anonymous unions don't have their own access. */
923 if (ANON_AGGR_TYPE_P (type
))
924 type
= type_context_for_name_lookup (type
);
926 /* [class.access.base]
928 A member m is accessible when named in class N if
930 --m as a member of N is public, or
932 --m as a member of N is private, and the reference occurs in a
933 member or friend of class N, or
935 --m as a member of N is protected, and the reference occurs in a
936 member or friend of class N, or in a member or friend of a
937 class P derived from N, where m as a member of P is public, private or
940 --there exists a base class B of N that is accessible at the point
941 of reference, and m is accessible when named in class B.
943 We walk the base class hierarchy, checking these conditions. */
945 /* We walk using TYPE_BINFO (type) because access_in_type will set
946 BINFO_ACCESS on it and its bases. */
947 binfo
= TYPE_BINFO (type
);
949 /* Compute the accessibility of DECL in the class hierarchy
950 dominated by type. */
951 access
= access_in_type (type
, decl
);
952 if (access
== ak_public
)
955 /* If we aren't considering the point of reference, only the first bullet
957 if (!consider_local_p
)
960 dfs_accessible_data d
= { decl
, otype
};
962 /* Walk the hierarchy again, looking for a base class that allows
964 return dfs_walk_once_accessible (binfo
, /*friends=*/true,
966 dfs_accessible_post
, &d
)
970 struct lookup_field_info
{
971 /* The type in which we're looking. */
973 /* The name of the field for which we're looking. */
975 /* If non-NULL, the current result of the lookup. */
977 /* The path to RVAL. */
979 /* If non-NULL, the lookup was ambiguous, and this is a list of the
982 /* If nonzero, we are looking for types, not data members. */
986 /* True for a class member means that it is shared between all objects
989 [class.member.lookup]:If the resulting set of declarations are not all
990 from sub-objects of the same type, or the set has a non-static member
991 and includes members from distinct sub-objects, there is an ambiguity
992 and the program is ill-formed.
994 This function checks that T contains no non-static members. */
997 shared_member_p (tree t
)
999 if (VAR_P (t
) || TREE_CODE (t
) == TYPE_DECL
1000 || TREE_CODE (t
) == CONST_DECL
)
1002 if (is_overloaded_fn (t
))
1004 for (ovl_iterator
iter (get_fns (t
)); iter
; ++iter
)
1006 tree decl
= strip_using_decl (*iter
);
1007 if (TREE_CODE (decl
) == USING_DECL
)
1008 /* Conservatively assume a dependent using-declaration
1009 might resolve to a non-static member. */
1011 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1019 /* Routine to see if the sub-object denoted by the binfo PARENT can be
1020 found as a base class and sub-object of the object denoted by
1024 is_subobject_of_p (tree parent
, tree binfo
)
1028 for (probe
= parent
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
1032 if (BINFO_VIRTUAL_P (probe
))
1033 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (binfo
))
1039 /* DATA is really a struct lookup_field_info. Look for a field with
1040 the name indicated there in BINFO. If this function returns a
1041 non-NULL value it is the result of the lookup. Called from
1042 lookup_field via breadth_first_search. */
1045 lookup_field_r (tree binfo
, void *data
)
1047 struct lookup_field_info
*lfi
= (struct lookup_field_info
*) data
;
1048 tree type
= BINFO_TYPE (binfo
);
1049 tree nval
= NULL_TREE
;
1051 /* If this is a dependent base, don't look in it. */
1052 if (BINFO_DEPENDENT_BASE_P (binfo
))
1055 /* If this base class is hidden by the best-known value so far, we
1056 don't need to look. */
1057 if (lfi
->rval_binfo
&& BINFO_INHERITANCE_CHAIN (binfo
) == lfi
->rval_binfo
1058 && !BINFO_VIRTUAL_P (binfo
))
1059 return dfs_skip_bases
;
1061 nval
= get_class_binding (type
, lfi
->name
, lfi
->want_type
);
1063 /* If there is no declaration with the indicated name in this type,
1064 then there's nothing to do. */
1068 /* If the lookup already found a match, and the new value doesn't
1069 hide the old one, we might have an ambiguity. */
1071 && !is_subobject_of_p (lfi
->rval_binfo
, binfo
))
1074 if (nval
== lfi
->rval
&& shared_member_p (nval
))
1075 /* The two things are really the same. */
1077 else if (is_subobject_of_p (binfo
, lfi
->rval_binfo
))
1078 /* The previous value hides the new one. */
1082 /* We have a real ambiguity. We keep a chain of all the
1084 if (!lfi
->ambiguous
&& lfi
->rval
)
1086 /* This is the first time we noticed an ambiguity. Add
1087 what we previously thought was a reasonable candidate
1089 lfi
->ambiguous
= tree_cons (NULL_TREE
, lfi
->rval
, NULL_TREE
);
1090 TREE_TYPE (lfi
->ambiguous
) = error_mark_node
;
1093 /* Add the new value. */
1094 lfi
->ambiguous
= tree_cons (NULL_TREE
, nval
, lfi
->ambiguous
);
1095 TREE_TYPE (lfi
->ambiguous
) = error_mark_node
;
1101 lfi
->rval_binfo
= binfo
;
1105 /* Don't look for constructors or destructors in base classes. */
1106 if (IDENTIFIER_CDTOR_P (lfi
->name
))
1107 return dfs_skip_bases
;
1111 /* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO,
1112 BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO,
1113 FUNCTIONS, and OPTYPE respectively. */
1116 build_baselink (tree binfo
, tree access_binfo
, tree functions
, tree optype
)
1120 gcc_assert (OVL_P (functions
) || TREE_CODE (functions
) == TEMPLATE_ID_EXPR
);
1121 gcc_assert (!optype
|| TYPE_P (optype
));
1122 gcc_assert (TREE_TYPE (functions
));
1124 baselink
= make_node (BASELINK
);
1125 TREE_TYPE (baselink
) = TREE_TYPE (functions
);
1126 BASELINK_BINFO (baselink
) = binfo
;
1127 BASELINK_ACCESS_BINFO (baselink
) = access_binfo
;
1128 BASELINK_FUNCTIONS (baselink
) = functions
;
1129 BASELINK_OPTYPE (baselink
) = optype
;
1131 if (binfo
== access_binfo
1132 && TYPE_BEING_DEFINED (BINFO_TYPE (access_binfo
)))
1133 BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P (baselink
) = true;
1138 /* Look for a member named NAME in an inheritance lattice dominated by
1139 XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
1140 is 1, we enforce accessibility. If PROTECT is zero, then, for an
1141 ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
1142 messages about inaccessible or ambiguous lookup. If PROTECT is 2,
1143 we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
1144 TREE_VALUEs are the list of ambiguous candidates.
1146 WANT_TYPE is 1 when we should only return TYPE_DECLs.
1148 If nothing can be found return NULL_TREE and do not issue an error.
1150 If non-NULL, failure information is written back to AFI. */
1153 lookup_member (tree xbasetype
, tree name
, int protect
, bool want_type
,
1154 tsubst_flags_t complain
, access_failure_info
*afi
/* = NULL */)
1156 tree rval
, rval_binfo
= NULL_TREE
;
1157 tree type
= NULL_TREE
, basetype_path
= NULL_TREE
;
1158 struct lookup_field_info lfi
;
1160 /* rval_binfo is the binfo associated with the found member, note,
1161 this can be set with useful information, even when rval is not
1162 set, because it must deal with ALL members, not just non-function
1163 members. It is used for ambiguity checking and the hidden
1164 checks. Whereas rval is only set if a proper (not hidden)
1165 non-function member is found. */
1167 if (name
== error_mark_node
1168 || xbasetype
== NULL_TREE
1169 || xbasetype
== error_mark_node
)
1172 gcc_assert (identifier_p (name
));
1174 if (TREE_CODE (xbasetype
) == TREE_BINFO
)
1176 type
= BINFO_TYPE (xbasetype
);
1177 basetype_path
= xbasetype
;
1181 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype
)))
1184 xbasetype
= NULL_TREE
;
1187 type
= complete_type (type
);
1189 /* Make sure we're looking for a member of the current instantiation in the
1190 right partial specialization. */
1191 if (dependent_type_p (type
))
1192 if (tree t
= currently_open_class (type
))
1196 basetype_path
= TYPE_BINFO (type
);
1201 memset (&lfi
, 0, sizeof (lfi
));
1204 lfi
.want_type
= want_type
;
1205 dfs_walk_all (basetype_path
, &lookup_field_r
, NULL
, &lfi
);
1207 rval_binfo
= lfi
.rval_binfo
;
1209 type
= BINFO_TYPE (rval_binfo
);
1215 else if (protect
== 1)
1217 if (complain
& tf_error
)
1219 error ("request for member %qD is ambiguous", name
);
1220 print_candidates (lfi
.ambiguous
);
1222 return error_mark_node
;
1224 else if (protect
== 2)
1225 return lfi
.ambiguous
;
1233 In the case of overloaded function names, access control is
1234 applied to the function selected by overloaded resolution.
1236 We cannot check here, even if RVAL is only a single non-static
1237 member function, since we do not know what the "this" pointer
1240 class A { protected: void f(); };
1241 class B : public A {
1248 only the first call to "f" is valid. However, if the function is
1249 static, we can check. */
1250 if (protect
== 1 && !really_overloaded_fn (rval
))
1252 tree decl
= is_overloaded_fn (rval
) ? get_first_fn (rval
) : rval
;
1253 decl
= strip_using_decl (decl
);
1254 /* A dependent USING_DECL will be checked after tsubsting. */
1255 if (TREE_CODE (decl
) != USING_DECL
1256 && !DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
)
1257 && !perform_or_defer_access_check (basetype_path
, decl
, decl
,
1259 return error_mark_node
;
1262 if (is_overloaded_fn (rval
)
1263 /* Don't use a BASELINK for class-scope deduction guides since
1264 they're not actually member functions. */
1265 && !dguide_name_p (name
))
1266 rval
= build_baselink (rval_binfo
, basetype_path
, rval
,
1267 (IDENTIFIER_CONV_OP_P (name
)
1268 ? TREE_TYPE (name
): NULL_TREE
));
1272 /* Helper class for lookup_member_fuzzy. */
1274 class lookup_field_fuzzy_info
1277 lookup_field_fuzzy_info (bool want_type_p
) :
1278 m_want_type_p (want_type_p
), m_candidates () {}
1280 void fuzzy_lookup_field (tree type
);
1282 /* If true, we are looking for types, not data members. */
1284 /* The result: a vec of identifiers. */
1285 auto_vec
<tree
> m_candidates
;
1288 /* Locate all fields within TYPE, append them to m_candidates. */
1291 lookup_field_fuzzy_info::fuzzy_lookup_field (tree type
)
1293 if (!CLASS_TYPE_P (type
))
1296 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1298 if (m_want_type_p
&& !DECL_DECLARES_TYPE_P (field
))
1301 if (!DECL_NAME (field
))
1304 if (is_lambda_ignored_entity (field
))
1307 /* Ignore special identifiers with space at the end like cdtor or
1308 conversion op identifiers. */
1309 if (TREE_CODE (DECL_NAME (field
)) == IDENTIFIER_NODE
)
1310 if (unsigned int len
= IDENTIFIER_LENGTH (DECL_NAME (field
)))
1311 if (IDENTIFIER_POINTER (DECL_NAME (field
))[len
- 1] == ' ')
1314 m_candidates
.safe_push (DECL_NAME (field
));
1319 /* Helper function for lookup_member_fuzzy, called via dfs_walk_all
1320 DATA is really a lookup_field_fuzzy_info. Look for a field with
1321 the name indicated there in BINFO. Gathers pertinent identifiers into
1325 lookup_field_fuzzy_r (tree binfo
, void *data
)
1327 lookup_field_fuzzy_info
*lffi
= (lookup_field_fuzzy_info
*) data
;
1328 tree type
= BINFO_TYPE (binfo
);
1330 lffi
->fuzzy_lookup_field (type
);
1335 /* Like lookup_member, but try to find the closest match for NAME,
1336 rather than an exact match, and return an identifier (or NULL_TREE).
1340 lookup_member_fuzzy (tree xbasetype
, tree name
, bool want_type_p
)
1342 tree type
= NULL_TREE
, basetype_path
= NULL_TREE
;
1343 class lookup_field_fuzzy_info
lffi (want_type_p
);
1345 /* rval_binfo is the binfo associated with the found member, note,
1346 this can be set with useful information, even when rval is not
1347 set, because it must deal with ALL members, not just non-function
1348 members. It is used for ambiguity checking and the hidden
1349 checks. Whereas rval is only set if a proper (not hidden)
1350 non-function member is found. */
1352 if (name
== error_mark_node
1353 || xbasetype
== NULL_TREE
1354 || xbasetype
== error_mark_node
)
1357 gcc_assert (identifier_p (name
));
1359 if (TREE_CODE (xbasetype
) == TREE_BINFO
)
1361 type
= BINFO_TYPE (xbasetype
);
1362 basetype_path
= xbasetype
;
1366 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype
)))
1369 xbasetype
= NULL_TREE
;
1372 type
= complete_type (type
);
1374 /* Make sure we're looking for a member of the current instantiation in the
1375 right partial specialization. */
1376 if (flag_concepts
&& dependent_type_p (type
))
1377 type
= currently_open_class (type
);
1380 basetype_path
= TYPE_BINFO (type
);
1385 /* Populate lffi.m_candidates. */
1386 dfs_walk_all (basetype_path
, &lookup_field_fuzzy_r
, NULL
, &lffi
);
1388 return find_closest_identifier (name
, &lffi
.m_candidates
);
1391 /* Like lookup_member, except that if we find a function member we
1392 return NULL_TREE. */
1395 lookup_field (tree xbasetype
, tree name
, int protect
, bool want_type
)
1397 tree rval
= lookup_member (xbasetype
, name
, protect
, want_type
,
1398 tf_warning_or_error
);
1400 /* Ignore functions, but propagate the ambiguity list. */
1401 if (!error_operand_p (rval
)
1402 && (rval
&& BASELINK_P (rval
)))
1408 /* Like lookup_member, except that if we find a non-function member we
1409 return NULL_TREE. */
1412 lookup_fnfields (tree xbasetype
, tree name
, int protect
,
1413 tsubst_flags_t complain
)
1415 tree rval
= lookup_member (xbasetype
, name
, protect
, /*want_type=*/false,
1418 /* Ignore non-functions, but propagate the ambiguity list. */
1419 if (!error_operand_p (rval
)
1420 && (rval
&& !BASELINK_P (rval
)))
1426 /* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
1427 the class or namespace used to qualify the name. CONTEXT_CLASS is
1428 the class corresponding to the object in which DECL will be used.
1429 Return a possibly modified version of DECL that takes into account
1432 In particular, consider an expression like `B::m' in the context of
1433 a derived class `D'. If `B::m' has been resolved to a BASELINK,
1434 then the most derived class indicated by the BASELINK_BINFO will be
1435 `B', not `D'. This function makes that adjustment. */
1438 adjust_result_of_qualified_name_lookup (tree decl
,
1439 tree qualifying_scope
,
1442 if (context_class
&& context_class
!= error_mark_node
1443 && CLASS_TYPE_P (context_class
)
1444 && CLASS_TYPE_P (qualifying_scope
)
1445 && DERIVED_FROM_P (qualifying_scope
, context_class
)
1446 && BASELINK_P (decl
))
1450 /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
1451 Because we do not yet know which function will be chosen by
1452 overload resolution, we cannot yet check either accessibility
1453 or ambiguity -- in either case, the choice of a static member
1454 function might make the usage valid. */
1455 base
= lookup_base (context_class
, qualifying_scope
,
1456 ba_unique
, NULL
, tf_none
);
1457 if (base
&& base
!= error_mark_node
)
1459 BASELINK_ACCESS_BINFO (decl
) = base
;
1461 = lookup_base (base
, BINFO_TYPE (BASELINK_BINFO (decl
)),
1462 ba_unique
, NULL
, tf_none
);
1463 if (decl_binfo
&& decl_binfo
!= error_mark_node
)
1464 BASELINK_BINFO (decl
) = decl_binfo
;
1468 if (BASELINK_P (decl
))
1469 BASELINK_QUALIFIED_P (decl
) = true;
1475 /* Walk the class hierarchy within BINFO, in a depth-first traversal.
1476 PRE_FN is called in preorder, while POST_FN is called in postorder.
1477 If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
1478 walked. If PRE_FN or POST_FN returns a different non-NULL value,
1479 that value is immediately returned and the walk is terminated. One
1480 of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
1481 POST_FN are passed the binfo to examine and the caller's DATA
1482 value. All paths are walked, thus virtual and morally virtual
1483 binfos can be multiply walked. */
1486 dfs_walk_all (tree binfo
, tree (*pre_fn
) (tree
, void *),
1487 tree (*post_fn
) (tree
, void *), void *data
)
1493 /* Call the pre-order walking function. */
1496 rval
= pre_fn (binfo
, data
);
1499 if (rval
== dfs_skip_bases
)
1505 /* Find the next child binfo to walk. */
1506 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1508 rval
= dfs_walk_all (base_binfo
, pre_fn
, post_fn
, data
);
1514 /* Call the post-order walking function. */
1517 rval
= post_fn (binfo
, data
);
1518 gcc_assert (rval
!= dfs_skip_bases
);
1525 /* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1526 that binfos are walked at most once. */
1529 dfs_walk_once_r (tree binfo
, tree (*pre_fn
) (tree
, void *),
1530 tree (*post_fn
) (tree
, void *), hash_set
<tree
> *pset
,
1537 /* Call the pre-order walking function. */
1540 rval
= pre_fn (binfo
, data
);
1543 if (rval
== dfs_skip_bases
)
1550 /* Find the next child binfo to walk. */
1551 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1553 if (BINFO_VIRTUAL_P (base_binfo
))
1554 if (pset
->add (base_binfo
))
1557 rval
= dfs_walk_once_r (base_binfo
, pre_fn
, post_fn
, pset
, data
);
1563 /* Call the post-order walking function. */
1566 rval
= post_fn (binfo
, data
);
1567 gcc_assert (rval
!= dfs_skip_bases
);
1574 /* Like dfs_walk_all, except that binfos are not multiply walked. For
1575 non-diamond shaped hierarchies this is the same as dfs_walk_all.
1576 For diamond shaped hierarchies we must mark the virtual bases, to
1577 avoid multiple walks. */
1580 dfs_walk_once (tree binfo
, tree (*pre_fn
) (tree
, void *),
1581 tree (*post_fn
) (tree
, void *), void *data
)
1583 static int active
= 0; /* We must not be called recursively. */
1586 gcc_assert (pre_fn
|| post_fn
);
1587 gcc_assert (!active
);
1590 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
)))
1591 /* We are not diamond shaped, and therefore cannot encounter the
1592 same binfo twice. */
1593 rval
= dfs_walk_all (binfo
, pre_fn
, post_fn
, data
);
1596 hash_set
<tree
> pset
;
1597 rval
= dfs_walk_once_r (binfo
, pre_fn
, post_fn
, &pset
, data
);
1605 /* Worker function for dfs_walk_once_accessible. Behaves like
1606 dfs_walk_once_r, except (a) FRIENDS_P is true if special
1607 access given by the current context should be considered, (b) ONCE
1608 indicates whether bases should be marked during traversal. */
1611 dfs_walk_once_accessible_r (tree binfo
, bool friends_p
, hash_set
<tree
> *pset
,
1612 tree (*pre_fn
) (tree
, void *),
1613 tree (*post_fn
) (tree
, void *), void *data
)
1615 tree rval
= NULL_TREE
;
1619 /* Call the pre-order walking function. */
1622 rval
= pre_fn (binfo
, data
);
1625 if (rval
== dfs_skip_bases
)
1632 /* Find the next child binfo to walk. */
1633 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1635 bool mark
= pset
&& BINFO_VIRTUAL_P (base_binfo
);
1637 if (mark
&& pset
->contains (base_binfo
))
1640 /* If the base is inherited via private or protected
1641 inheritance, then we can't see it, unless we are a friend of
1642 the current binfo. */
1643 if (BINFO_BASE_ACCESS (binfo
, ix
) != access_public_node
)
1648 scope
= current_scope ();
1650 || TREE_CODE (scope
) == NAMESPACE_DECL
1651 || !is_friend (BINFO_TYPE (binfo
), scope
))
1656 pset
->add (base_binfo
);
1658 rval
= dfs_walk_once_accessible_r (base_binfo
, friends_p
, pset
,
1659 pre_fn
, post_fn
, data
);
1665 /* Call the post-order walking function. */
1668 rval
= post_fn (binfo
, data
);
1669 gcc_assert (rval
!= dfs_skip_bases
);
1676 /* Like dfs_walk_once except that only accessible bases are walked.
1677 FRIENDS_P indicates whether friendship of the local context
1678 should be considered when determining accessibility. */
1681 dfs_walk_once_accessible (tree binfo
, bool friends_p
,
1682 tree (*pre_fn
) (tree
, void *),
1683 tree (*post_fn
) (tree
, void *), void *data
)
1685 hash_set
<tree
> *pset
= NULL
;
1686 if (CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
)))
1687 pset
= new hash_set
<tree
>;
1688 tree rval
= dfs_walk_once_accessible_r (binfo
, friends_p
, pset
,
1689 pre_fn
, post_fn
, data
);
1696 /* Return true iff the code of T is CODE, and it has compatible
1700 matches_code_and_type_p (tree t
, enum tree_code code
, tree type
)
1702 if (TREE_CODE (t
) != code
)
1704 if (!cxx_types_compatible_p (TREE_TYPE (t
), type
))
1709 /* Subroutine of direct_accessor_p and reference_accessor_p.
1710 Determine if COMPONENT_REF is a simple field lookup of this->FIELD_DECL.
1711 We expect a tree of the form:
1716 <field_decl (FIELD_DECL)>>>. */
1719 field_access_p (tree component_ref
, tree field_decl
, tree field_type
)
1721 if (!matches_code_and_type_p (component_ref
, COMPONENT_REF
, field_type
))
1724 tree indirect_ref
= TREE_OPERAND (component_ref
, 0);
1725 if (!INDIRECT_REF_P (indirect_ref
))
1728 tree ptr
= STRIP_NOPS (TREE_OPERAND (indirect_ref
, 0));
1729 if (!is_this_parameter (ptr
))
1732 /* Must access the correct field. */
1733 if (TREE_OPERAND (component_ref
, 1) != field_decl
)
1738 /* Subroutine of field_accessor_p.
1740 Assuming that INIT_EXPR has already had its code and type checked,
1741 determine if it is a simple accessor for FIELD_DECL
1742 (of type FIELD_TYPE).
1744 Specifically, a simple accessor within struct S of the form:
1745 T get_field () { return m_field; }
1746 should have a constexpr_fn_retval (saved_tree) of the form:
1754 <field_decl (FIELD_DECL)>>>>>. */
1757 direct_accessor_p (tree init_expr
, tree field_decl
, tree field_type
)
1759 tree result_decl
= TREE_OPERAND (init_expr
, 0);
1760 if (!matches_code_and_type_p (result_decl
, RESULT_DECL
, field_type
))
1763 tree component_ref
= STRIP_NOPS (TREE_OPERAND (init_expr
, 1));
1764 if (!field_access_p (component_ref
, field_decl
, field_type
))
1770 /* Subroutine of field_accessor_p.
1772 Assuming that INIT_EXPR has already had its code and type checked,
1773 determine if it is a "reference" accessor for FIELD_DECL
1774 (of type FIELD_REFERENCE_TYPE).
1776 Specifically, a simple accessor within struct S of the form:
1777 T& get_field () { return m_field; }
1778 should have a constexpr_fn_retval (saved_tree) of the form:
1787 <field (FIELD_DECL)>>>>>>. */
1789 reference_accessor_p (tree init_expr
, tree field_decl
, tree field_type
,
1790 tree field_reference_type
)
1792 tree result_decl
= TREE_OPERAND (init_expr
, 0);
1793 if (!matches_code_and_type_p (result_decl
, RESULT_DECL
, field_reference_type
))
1796 tree field_pointer_type
= build_pointer_type (field_type
);
1797 tree addr_expr
= STRIP_NOPS (TREE_OPERAND (init_expr
, 1));
1798 if (!matches_code_and_type_p (addr_expr
, ADDR_EXPR
, field_pointer_type
))
1801 tree component_ref
= STRIP_NOPS (TREE_OPERAND (addr_expr
, 0));
1803 if (!field_access_p (component_ref
, field_decl
, field_type
))
1809 /* Return true if FN is an accessor method for FIELD_DECL.
1810 i.e. a method of the form { return FIELD; }, with no
1813 If CONST_P, then additionally require that FN be a const
1817 field_accessor_p (tree fn
, tree field_decl
, bool const_p
)
1819 if (TREE_CODE (fn
) != FUNCTION_DECL
)
1822 /* We don't yet support looking up static data, just fields. */
1823 if (TREE_CODE (field_decl
) != FIELD_DECL
)
1826 tree fntype
= TREE_TYPE (fn
);
1827 if (TREE_CODE (fntype
) != METHOD_TYPE
)
1830 /* If the field is accessed via a const "this" argument, verify
1831 that the "this" parameter is const. */
1834 tree this_class
= class_of_this_parm (fntype
);
1835 if (!TYPE_READONLY (this_class
))
1839 tree saved_tree
= DECL_SAVED_TREE (fn
);
1841 if (saved_tree
== NULL_TREE
)
1844 /* Attempt to extract a single return value from the function,
1846 tree retval
= constexpr_fn_retval (saved_tree
);
1847 if (retval
== NULL_TREE
|| retval
== error_mark_node
)
1849 /* Require an INIT_EXPR. */
1850 if (TREE_CODE (retval
) != INIT_EXPR
)
1852 tree init_expr
= retval
;
1854 /* Determine if this is a simple accessor within struct S of the form:
1855 T get_field () { return m_field; }. */
1856 tree field_type
= TREE_TYPE (field_decl
);
1857 if (cxx_types_compatible_p (TREE_TYPE (init_expr
), field_type
))
1858 return direct_accessor_p (init_expr
, field_decl
, field_type
);
1860 /* Failing that, determine if it is an accessor of the form:
1861 T& get_field () { return m_field; }. */
1862 tree field_reference_type
= cp_build_reference_type (field_type
, false);
1863 if (cxx_types_compatible_p (TREE_TYPE (init_expr
), field_reference_type
))
1864 return reference_accessor_p (init_expr
, field_decl
, field_type
,
1865 field_reference_type
);
1870 /* Callback data for dfs_locate_field_accessor_pre. */
1872 class locate_field_data
1875 locate_field_data (tree field_decl_
, bool const_p_
)
1876 : field_decl (field_decl_
), const_p (const_p_
) {}
1882 /* Return a FUNCTION_DECL that is an "accessor" method for DATA, a FIELD_DECL,
1883 callable via binfo, if one exists, otherwise return NULL_TREE.
1885 Callback for dfs_walk_once_accessible for use within
1886 locate_field_accessor. */
1889 dfs_locate_field_accessor_pre (tree binfo
, void *data
)
1891 locate_field_data
*lfd
= (locate_field_data
*)data
;
1892 tree type
= BINFO_TYPE (binfo
);
1894 vec
<tree
, va_gc
> *member_vec
;
1898 if (!CLASS_TYPE_P (type
))
1901 member_vec
= CLASSTYPE_MEMBER_VEC (type
);
1905 for (i
= 0; vec_safe_iterate (member_vec
, i
, &fn
); ++i
)
1907 if (field_accessor_p (fn
, lfd
->field_decl
, lfd
->const_p
))
1913 /* Return a FUNCTION_DECL that is an "accessor" method for FIELD_DECL,
1914 callable via BASETYPE_PATH, if one exists, otherwise return NULL_TREE. */
1917 locate_field_accessor (tree basetype_path
, tree field_decl
, bool const_p
)
1919 if (TREE_CODE (basetype_path
) != TREE_BINFO
)
1922 /* Walk the hierarchy, looking for a method of some base class that allows
1923 access to the field. */
1924 locate_field_data
lfd (field_decl
, const_p
);
1925 return dfs_walk_once_accessible (basetype_path
, /*friends=*/true,
1926 dfs_locate_field_accessor_pre
,
1930 /* Check throw specifier of OVERRIDER is at least as strict as
1931 the one of BASEFN. */
1934 maybe_check_overriding_exception_spec (tree overrider
, tree basefn
)
1936 maybe_instantiate_noexcept (basefn
);
1937 maybe_instantiate_noexcept (overrider
);
1938 tree base_throw
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (basefn
));
1939 tree over_throw
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (overrider
));
1941 if (DECL_INVALID_OVERRIDER_P (overrider
))
1944 /* Can't check this yet. Pretend this is fine and let
1945 noexcept_override_late_checks check this later. */
1946 if (UNPARSED_NOEXCEPT_SPEC_P (base_throw
)
1947 || UNPARSED_NOEXCEPT_SPEC_P (over_throw
))
1950 if (!comp_except_specs (base_throw
, over_throw
, ce_derived
))
1952 auto_diagnostic_group d
;
1953 error ("looser exception specification on overriding virtual function "
1954 "%q+#F", overrider
);
1955 inform (DECL_SOURCE_LOCATION (basefn
),
1956 "overridden function is %q#F", basefn
);
1957 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
1963 /* Check that virtual overrider OVERRIDER is acceptable for base function
1964 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
1967 check_final_overrider (tree overrider
, tree basefn
)
1969 tree over_type
= TREE_TYPE (overrider
);
1970 tree base_type
= TREE_TYPE (basefn
);
1971 tree over_return
= fndecl_declared_return_type (overrider
);
1972 tree base_return
= fndecl_declared_return_type (basefn
);
1976 if (DECL_INVALID_OVERRIDER_P (overrider
))
1979 if (same_type_p (base_return
, over_return
))
1981 else if ((CLASS_TYPE_P (over_return
) && CLASS_TYPE_P (base_return
))
1982 || (TREE_CODE (base_return
) == TREE_CODE (over_return
)
1983 && INDIRECT_TYPE_P (base_return
)))
1985 /* Potentially covariant. */
1986 unsigned base_quals
, over_quals
;
1988 fail
= !INDIRECT_TYPE_P (base_return
);
1991 if (cp_type_quals (base_return
) != cp_type_quals (over_return
))
1994 if (TYPE_REF_P (base_return
)
1995 && (TYPE_REF_IS_RVALUE (base_return
)
1996 != TYPE_REF_IS_RVALUE (over_return
)))
1999 base_return
= TREE_TYPE (base_return
);
2000 over_return
= TREE_TYPE (over_return
);
2002 base_quals
= cp_type_quals (base_return
);
2003 over_quals
= cp_type_quals (over_return
);
2005 if ((base_quals
& over_quals
) != over_quals
)
2008 if (CLASS_TYPE_P (base_return
) && CLASS_TYPE_P (over_return
))
2010 /* Strictly speaking, the standard requires the return type to be
2011 complete even if it only differs in cv-quals, but that seems
2012 like a bug in the wording. */
2013 if (!same_type_ignoring_top_level_qualifiers_p (base_return
,
2016 tree binfo
= lookup_base (over_return
, base_return
,
2017 ba_check
, NULL
, tf_none
);
2019 if (!binfo
|| binfo
== error_mark_node
)
2023 else if (can_convert_standard (TREE_TYPE (base_type
),
2024 TREE_TYPE (over_type
),
2025 tf_warning_or_error
))
2026 /* GNU extension, allow trivial pointer conversions such as
2027 converting to void *, or qualification conversion. */
2029 auto_diagnostic_group d
;
2030 if (pedwarn (DECL_SOURCE_LOCATION (overrider
), 0,
2031 "invalid covariant return type for %q#D", overrider
))
2032 inform (DECL_SOURCE_LOCATION (basefn
),
2033 "overridden function is %q#D", basefn
);
2044 auto_diagnostic_group d
;
2046 error ("invalid covariant return type for %q+#D", overrider
);
2048 error ("conflicting return type specified for %q+#D", overrider
);
2049 inform (DECL_SOURCE_LOCATION (basefn
),
2050 "overridden function is %q#D", basefn
);
2051 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2055 if (!maybe_check_overriding_exception_spec (overrider
, basefn
))
2058 /* Check for conflicting type attributes. But leave transaction_safe for
2059 set_one_vmethod_tm_attributes. */
2060 if (!comp_type_attributes (over_type
, base_type
)
2061 && !tx_safe_fn_type_p (base_type
)
2062 && !tx_safe_fn_type_p (over_type
))
2064 auto_diagnostic_group d
;
2065 error ("conflicting type attributes specified for %q+#D", overrider
);
2066 inform (DECL_SOURCE_LOCATION (basefn
),
2067 "overridden function is %q#D", basefn
);
2068 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2072 /* A consteval virtual function shall not override a virtual function that is
2073 not consteval. A consteval virtual function shall not be overridden by a
2074 virtual function that is not consteval. */
2075 if (DECL_IMMEDIATE_FUNCTION_P (overrider
)
2076 != DECL_IMMEDIATE_FUNCTION_P (basefn
))
2078 auto_diagnostic_group d
;
2079 if (DECL_IMMEDIATE_FUNCTION_P (overrider
))
2080 error ("%<consteval%> function %q+D overriding non-%<consteval%> "
2081 "function", overrider
);
2083 error ("non-%<consteval%> function %q+D overriding %<consteval%> "
2084 "function", overrider
);
2085 inform (DECL_SOURCE_LOCATION (basefn
),
2086 "overridden function is %qD", basefn
);
2087 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2091 /* A function declared transaction_safe_dynamic that overrides a function
2092 declared transaction_safe (but not transaction_safe_dynamic) is
2094 if (tx_safe_fn_type_p (base_type
)
2095 && lookup_attribute ("transaction_safe_dynamic",
2096 DECL_ATTRIBUTES (overrider
))
2097 && !lookup_attribute ("transaction_safe_dynamic",
2098 DECL_ATTRIBUTES (basefn
)))
2100 auto_diagnostic_group d
;
2101 error_at (DECL_SOURCE_LOCATION (overrider
),
2102 "%qD declared %<transaction_safe_dynamic%>", overrider
);
2103 inform (DECL_SOURCE_LOCATION (basefn
),
2104 "overriding %qD declared %<transaction_safe%>", basefn
);
2107 if (DECL_DELETED_FN (basefn
) != DECL_DELETED_FN (overrider
))
2109 if (DECL_DELETED_FN (overrider
))
2111 auto_diagnostic_group d
;
2112 error ("deleted function %q+D overriding non-deleted function",
2114 inform (DECL_SOURCE_LOCATION (basefn
),
2115 "overridden function is %qD", basefn
);
2116 maybe_explain_implicit_delete (overrider
);
2120 auto_diagnostic_group d
;
2121 error ("non-deleted function %q+D overriding deleted function",
2123 inform (DECL_SOURCE_LOCATION (basefn
),
2124 "overridden function is %qD", basefn
);
2129 if (!DECL_HAS_CONTRACTS_P (basefn
) && DECL_HAS_CONTRACTS_P (overrider
))
2131 auto_diagnostic_group d
;
2132 error ("function with contracts %q+D overriding contractless function",
2134 inform (DECL_SOURCE_LOCATION (basefn
),
2135 "overridden function is %qD", basefn
);
2138 else if (DECL_HAS_CONTRACTS_P (basefn
) && !DECL_HAS_CONTRACTS_P (overrider
))
2140 /* We're inheriting basefn's contracts; create a copy of them but
2141 replace references to their parms to our parms. */
2142 inherit_base_contracts (overrider
, basefn
);
2144 else if (DECL_HAS_CONTRACTS_P (basefn
) && DECL_HAS_CONTRACTS_P (overrider
))
2146 /* We're in the process of completing the overrider's class, which means
2147 our conditions definitely are not parsed so simply chain on the
2148 basefn for later checking.
2150 Note that OVERRIDER's contracts will have been fully parsed at the
2151 point the deferred match is run. */
2152 defer_guarded_contract_match (overrider
, basefn
, DECL_CONTRACTS (basefn
));
2155 if (DECL_FINAL_P (basefn
))
2157 auto_diagnostic_group d
;
2158 error ("virtual function %q+D overriding final function", overrider
);
2159 inform (DECL_SOURCE_LOCATION (basefn
),
2160 "overridden function is %qD", basefn
);
2166 /* Given a class TYPE, and a function decl FNDECL, look for
2167 virtual functions in TYPE's hierarchy which FNDECL overrides.
2168 We do not look in TYPE itself, only its bases.
2170 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
2171 find that it overrides anything.
2173 We check that every function which is overridden, is correctly
2177 look_for_overrides (tree type
, tree fndecl
)
2179 tree binfo
= TYPE_BINFO (type
);
2184 /* A constructor for a class T does not override a function T
2186 if (DECL_CONSTRUCTOR_P (fndecl
))
2189 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2191 tree basetype
= BINFO_TYPE (base_binfo
);
2193 if (TYPE_POLYMORPHIC_P (basetype
))
2194 found
+= look_for_overrides_r (basetype
, fndecl
);
2199 /* Look in TYPE for virtual functions with the same signature as
2203 look_for_overrides_here (tree type
, tree fndecl
)
2205 tree ovl
= get_class_binding (type
, DECL_NAME (fndecl
));
2207 for (ovl_iterator
iter (ovl
); iter
; ++iter
)
2211 if (!DECL_VIRTUAL_P (fn
))
2212 /* Not a virtual. */;
2213 else if (DECL_CONTEXT (fn
) != type
)
2214 /* Introduced with a using declaration. */;
2215 else if (DECL_STATIC_FUNCTION_P (fndecl
))
2217 tree btypes
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2218 tree dtypes
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2219 if (compparms (TREE_CHAIN (btypes
), dtypes
))
2222 else if (same_signature_p (fndecl
, fn
))
2229 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
2230 TYPE itself and its bases. */
2233 look_for_overrides_r (tree type
, tree fndecl
)
2235 tree fn
= look_for_overrides_here (type
, fndecl
);
2238 if (DECL_STATIC_FUNCTION_P (fndecl
))
2240 /* A static member function cannot match an inherited
2241 virtual member function. */
2242 auto_diagnostic_group d
;
2243 error ("%q+#D cannot be declared", fndecl
);
2244 error (" since %q+#D declared in base class", fn
);
2248 /* It's definitely virtual, even if not explicitly set. */
2249 DECL_VIRTUAL_P (fndecl
) = 1;
2250 check_final_overrider (fndecl
, fn
);
2255 /* We failed to find one declared in this class. Look in its bases. */
2256 return look_for_overrides (type
, fndecl
);
2259 /* Called via dfs_walk from dfs_get_pure_virtuals. */
2262 dfs_get_pure_virtuals (tree binfo
, void *data
)
2264 tree type
= (tree
) data
;
2266 /* We're not interested in primary base classes; the derived class
2267 of which they are a primary base will contain the information we
2269 if (!BINFO_PRIMARY_P (binfo
))
2273 for (virtuals
= BINFO_VIRTUALS (binfo
);
2275 virtuals
= TREE_CHAIN (virtuals
))
2276 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals
)))
2277 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (type
), BV_FN (virtuals
));
2283 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
2286 get_pure_virtuals (tree type
)
2288 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
2289 is going to be overridden. */
2290 CLASSTYPE_PURE_VIRTUALS (type
) = NULL
;
2291 /* Now, run through all the bases which are not primary bases, and
2292 collect the pure virtual functions. We look at the vtable in
2293 each class to determine what pure virtual functions are present.
2294 (A primary base is not interesting because the derived class of
2295 which it is a primary base will contain vtable entries for the
2296 pure virtuals in the base class. */
2297 dfs_walk_once (TYPE_BINFO (type
), NULL
, dfs_get_pure_virtuals
, type
);
2300 /* Debug info for C++ classes can get very large; try to avoid
2301 emitting it everywhere.
2303 Note that this optimization wins even when the target supports
2304 BINCL (if only slightly), and reduces the amount of work for the
2308 maybe_suppress_debug_info (tree t
)
2310 if (write_symbols
== NO_DEBUG
)
2313 /* We might have set this earlier in cp_finish_decl. */
2314 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 0;
2316 /* Always emit the information for each class every time. */
2317 if (flag_emit_class_debug_always
)
2320 /* If we already know how we're handling this class, handle debug info
2322 if (CLASSTYPE_INTERFACE_KNOWN (t
))
2324 if (CLASSTYPE_INTERFACE_ONLY (t
))
2325 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2326 /* else don't set it. */
2328 /* If the class has a vtable, write out the debug info along with
2330 else if (TYPE_CONTAINS_VPTR_P (t
))
2331 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2333 /* Otherwise, just emit the debug info normally. */
2336 /* Note that we want debugging information for a base class of a class
2337 whose vtable is being emitted. Normally, this would happen because
2338 calling the constructor for a derived class implies calling the
2339 constructors for all bases, which involve initializing the
2340 appropriate vptr with the vtable for the base class; but in the
2341 presence of optimization, this initialization may be optimized
2342 away, so we tell finish_vtable_vardecl that we want the debugging
2343 information anyway. */
2346 dfs_debug_mark (tree binfo
, void * /*data*/)
2348 tree t
= BINFO_TYPE (binfo
);
2350 if (CLASSTYPE_DEBUG_REQUESTED (t
))
2351 return dfs_skip_bases
;
2353 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
2358 /* Write out the debugging information for TYPE, whose vtable is being
2359 emitted. Also walk through our bases and note that we want to
2360 write out information for them. This avoids the problem of not
2361 writing any debug info for intermediate basetypes whose
2362 constructors, and thus the references to their vtables, and thus
2363 the vtables themselves, were optimized away. */
2366 note_debug_info_needed (tree type
)
2368 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
2370 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)) = 0;
2371 rest_of_type_compilation (type
, namespace_bindings_p ());
2374 dfs_walk_all (TYPE_BINFO (type
), dfs_debug_mark
, NULL
, 0);
2377 /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2378 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2379 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2380 bases have been encountered already in the tree walk. PARENT_CONVS
2381 is the list of lists of conversion functions that could hide CONV
2382 and OTHER_CONVS is the list of lists of conversion functions that
2383 could hide or be hidden by CONV, should virtualness be involved in
2384 the hierarchy. Merely checking the conversion op's name is not
2385 enough because two conversion operators to the same type can have
2386 different names. Return nonzero if we are visible. */
2389 check_hidden_convs (tree binfo
, int virtual_depth
, int virtualness
,
2390 tree to_type
, tree parent_convs
, tree other_convs
)
2394 /* See if we are hidden by a parent conversion. */
2395 for (level
= parent_convs
; level
; level
= TREE_CHAIN (level
))
2396 for (probe
= TREE_VALUE (level
); probe
; probe
= TREE_CHAIN (probe
))
2397 if (same_type_p (to_type
, TREE_TYPE (probe
)))
2400 if (virtual_depth
|| virtualness
)
2402 /* In a virtual hierarchy, we could be hidden, or could hide a
2403 conversion function on the other_convs list. */
2404 for (level
= other_convs
; level
; level
= TREE_CHAIN (level
))
2410 if (!(virtual_depth
|| TREE_STATIC (level
)))
2411 /* Neither is morally virtual, so cannot hide each other. */
2414 if (!TREE_VALUE (level
))
2415 /* They evaporated away already. */
2418 they_hide_us
= (virtual_depth
2419 && original_binfo (binfo
, TREE_PURPOSE (level
)));
2420 we_hide_them
= (!they_hide_us
&& TREE_STATIC (level
)
2421 && original_binfo (TREE_PURPOSE (level
), binfo
));
2423 if (!(we_hide_them
|| they_hide_us
))
2424 /* Neither is within the other, so no hiding can occur. */
2427 for (prev
= &TREE_VALUE (level
), other
= *prev
; other
;)
2429 if (same_type_p (to_type
, TREE_TYPE (other
)))
2432 /* We are hidden. */
2437 /* We hide the other one. */
2438 other
= TREE_CHAIN (other
);
2443 prev
= &TREE_CHAIN (other
);
2451 /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2452 of conversion functions, the first slot will be for the current
2453 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2454 of conversion functions from children of the current binfo,
2455 concatenated with conversions from elsewhere in the hierarchy --
2456 that list begins with OTHER_CONVS. Return a single list of lists
2457 containing only conversions from the current binfo and its
2461 split_conversions (tree my_convs
, tree parent_convs
,
2462 tree child_convs
, tree other_convs
)
2467 /* Remove the original other_convs portion from child_convs. */
2468 for (prev
= NULL
, t
= child_convs
;
2469 t
!= other_convs
; prev
= t
, t
= TREE_CHAIN (t
))
2473 TREE_CHAIN (prev
) = NULL_TREE
;
2475 child_convs
= NULL_TREE
;
2477 /* Attach the child convs to any we had at this level. */
2480 my_convs
= parent_convs
;
2481 TREE_CHAIN (my_convs
) = child_convs
;
2484 my_convs
= child_convs
;
2489 /* Worker for lookup_conversions. Lookup conversion functions in
2490 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in a
2491 morally virtual base, and VIRTUALNESS is nonzero, if we've
2492 encountered virtual bases already in the tree walk. PARENT_CONVS
2493 is a list of conversions within parent binfos. OTHER_CONVS are
2494 conversions found elsewhere in the tree. Return the conversions
2495 found within this portion of the graph in CONVS. Return nonzero if
2496 we encountered virtualness. We keep template and non-template
2497 conversions separate, to avoid unnecessary type comparisons.
2499 The located conversion functions are held in lists of lists. The
2500 TREE_VALUE of the outer list is the list of conversion functions
2501 found in a particular binfo. The TREE_PURPOSE of both the outer
2502 and inner lists is the binfo at which those conversions were
2503 found. TREE_STATIC is set for those lists within of morally
2504 virtual binfos. The TREE_VALUE of the inner list is the conversion
2505 function or overload itself. The TREE_TYPE of each inner list node
2506 is the converted-to type. */
2509 lookup_conversions_r (tree binfo
, int virtual_depth
, int virtualness
,
2510 tree parent_convs
, tree other_convs
, tree
*convs
)
2512 int my_virtualness
= 0;
2513 tree my_convs
= NULL_TREE
;
2514 tree child_convs
= NULL_TREE
;
2516 /* If we have no conversion operators, then don't look. */
2517 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo
)))
2524 if (BINFO_VIRTUAL_P (binfo
))
2527 /* First, locate the unhidden ones at this level. */
2528 if (tree conv
= get_class_binding (BINFO_TYPE (binfo
), conv_op_identifier
))
2529 for (ovl_iterator
iter (conv
); iter
; ++iter
)
2532 tree type
= DECL_CONV_FN_TYPE (fn
);
2534 if (TREE_CODE (fn
) != TEMPLATE_DECL
&& type_uses_auto (type
))
2537 type
= DECL_CONV_FN_TYPE (fn
);
2540 if (check_hidden_convs (binfo
, virtual_depth
, virtualness
,
2541 type
, parent_convs
, other_convs
))
2543 my_convs
= tree_cons (binfo
, fn
, my_convs
);
2544 TREE_TYPE (my_convs
) = type
;
2547 TREE_STATIC (my_convs
) = 1;
2555 parent_convs
= tree_cons (binfo
, my_convs
, parent_convs
);
2557 TREE_STATIC (parent_convs
) = 1;
2560 child_convs
= other_convs
;
2562 /* Now iterate over each base, looking for more conversions. */
2565 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2568 unsigned base_virtualness
;
2570 base_virtualness
= lookup_conversions_r (base_binfo
,
2571 virtual_depth
, virtualness
,
2572 parent_convs
, child_convs
,
2574 if (base_virtualness
)
2575 my_virtualness
= virtualness
= 1;
2576 child_convs
= chainon (base_convs
, child_convs
);
2579 *convs
= split_conversions (my_convs
, parent_convs
,
2580 child_convs
, other_convs
);
2582 return my_virtualness
;
2585 /* Return a TREE_LIST containing all the non-hidden user-defined
2586 conversion functions for TYPE (and its base-classes). The
2587 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2588 function. The TREE_PURPOSE is the BINFO from which the conversion
2589 functions in this node were selected. This function is effectively
2590 performing a set of member lookups as lookup_fnfield does, but
2591 using the type being converted to as the unique key, rather than the
2595 lookup_conversions (tree type
)
2599 complete_type (type
);
2600 if (!CLASS_TYPE_P (type
) || !TYPE_BINFO (type
))
2603 lookup_conversions_r (TYPE_BINFO (type
), 0, 0, NULL_TREE
, NULL_TREE
, &convs
);
2605 tree list
= NULL_TREE
;
2607 /* Flatten the list-of-lists */
2608 for (; convs
; convs
= TREE_CHAIN (convs
))
2612 for (probe
= TREE_VALUE (convs
); probe
; probe
= next
)
2614 next
= TREE_CHAIN (probe
);
2616 TREE_CHAIN (probe
) = list
;
2624 /* Returns the binfo of the first direct or indirect virtual base derived
2625 from BINFO, or NULL if binfo is not via virtual. */
2628 binfo_from_vbase (tree binfo
)
2630 for (; binfo
; binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2632 if (BINFO_VIRTUAL_P (binfo
))
2638 /* Returns the binfo of the first direct or indirect virtual base derived
2639 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2643 binfo_via_virtual (tree binfo
, tree limit
)
2645 if (limit
&& !CLASSTYPE_VBASECLASSES (limit
))
2646 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2649 for (; binfo
&& !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), limit
);
2650 binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2652 if (BINFO_VIRTUAL_P (binfo
))
2658 /* BINFO is for a base class in some hierarchy. Return true iff it is a
2662 binfo_direct_p (tree binfo
)
2664 tree d_binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
2665 if (BINFO_INHERITANCE_CHAIN (d_binfo
))
2666 /* A second inheritance chain means indirect. */
2668 if (!BINFO_VIRTUAL_P (binfo
))
2669 /* Non-virtual, so only one inheritance chain means direct. */
2671 /* A virtual base looks like a direct base, so we need to look through the
2672 direct bases to see if it's there. */
2674 for (int i
= 0; BINFO_BASE_ITERATE (d_binfo
, i
, b_binfo
); ++i
)
2675 if (b_binfo
== binfo
)
2680 /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2681 Find the equivalent binfo within whatever graph HERE is located.
2682 This is the inverse of original_binfo. */
2685 copied_binfo (tree binfo
, tree here
)
2687 tree result
= NULL_TREE
;
2689 if (BINFO_VIRTUAL_P (binfo
))
2693 for (t
= here
; BINFO_INHERITANCE_CHAIN (t
);
2694 t
= BINFO_INHERITANCE_CHAIN (t
))
2697 result
= binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (t
));
2699 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2705 cbinfo
= copied_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2706 for (ix
= 0; BINFO_BASE_ITERATE (cbinfo
, ix
, base_binfo
); ix
++)
2707 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
), BINFO_TYPE (binfo
)))
2709 result
= base_binfo
;
2715 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here
), BINFO_TYPE (binfo
)));
2719 gcc_assert (result
);
2724 binfo_for_vbase (tree base
, tree t
)
2728 vec
<tree
, va_gc
> *vbases
;
2730 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
2731 vec_safe_iterate (vbases
, ix
, &binfo
); ix
++)
2732 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), base
))
2737 /* BINFO is some base binfo of HERE, within some other
2738 hierarchy. Return the equivalent binfo, but in the hierarchy
2739 dominated by HERE. This is the inverse of copied_binfo. If BINFO
2740 is not a base binfo of HERE, returns NULL_TREE. */
2743 original_binfo (tree binfo
, tree here
)
2747 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (here
)))
2749 else if (BINFO_VIRTUAL_P (binfo
))
2750 result
= (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here
))
2751 ? binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (here
))
2753 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2757 base_binfos
= original_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2763 for (ix
= 0; (base_binfo
= BINFO_BASE_BINFO (base_binfos
, ix
)); ix
++)
2764 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
2765 BINFO_TYPE (binfo
)))
2767 result
= base_binfo
;
2776 /* True iff TYPE has any dependent bases (and therefore we can't say
2777 definitively that another class is not a base of an instantiation of
2781 any_dependent_bases_p (tree type
)
2783 if (!type
|| !CLASS_TYPE_P (type
) || !uses_template_parms (type
))
2786 /* If we haven't set TYPE_BINFO yet, we don't know anything about the bases.
2787 Return false because in this situation we aren't actually looking up names
2788 in the scope of the class, so it doesn't matter whether it has dependent
2790 if (!TYPE_BINFO (type
))
2795 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_BINFOS (TYPE_BINFO (type
)), i
, base_binfo
)
2796 if (BINFO_DEPENDENT_BASE_P (base_binfo
))