1 /* Breadth-first and depth-first routines for
2 searching multiple-inheritance lattice for GNU C++.
3 Copyright (C) 1987-2022 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 tree t
; /* type being searched. */
60 tree base
; /* The base type we're looking for. */
61 tree binfo
; /* Found binfo. */
62 bool via_virtual
; /* Found via a virtual path. */
63 bool ambiguous
; /* Found multiply ambiguous */
64 bool repeated_base
; /* Whether there are repeated bases in the
66 bool want_any
; /* Whether we want any matching binfo. */
69 /* Worker function for lookup_base. See if we've found the desired
70 base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
73 dfs_lookup_base (tree binfo
, void *data_
)
75 struct lookup_base_data_s
*data
= (struct lookup_base_data_s
*) data_
;
77 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->base
))
83 = binfo_via_virtual (data
->binfo
, data
->t
) != NULL_TREE
;
85 if (!data
->repeated_base
)
86 /* If there are no repeated bases, we can stop now. */
89 if (data
->want_any
&& !data
->via_virtual
)
90 /* If this is a non-virtual base, then we can't do
94 return dfs_skip_bases
;
98 gcc_assert (binfo
!= data
->binfo
);
100 /* We've found more than one matching binfo. */
103 /* This is immediately ambiguous. */
104 data
->binfo
= NULL_TREE
;
105 data
->ambiguous
= true;
106 return error_mark_node
;
109 /* Prefer one via a non-virtual path. */
110 if (!binfo_via_virtual (binfo
, data
->t
))
113 data
->via_virtual
= false;
117 /* There must be repeated bases, otherwise we'd have stopped
118 on the first base we found. */
119 return dfs_skip_bases
;
126 /* This deals with bug PR17314.
128 DECL is a declaration and BINFO represents a class that has attempted (but
129 failed) to access DECL.
131 Examine the parent binfos of BINFO and determine whether any of them had
132 private access to DECL. If they did, return the parent binfo. This helps
133 in figuring out the correct error message to show (if the parents had
134 access, it's their fault for not giving sufficient access to BINFO).
136 If no parents had access, return NULL_TREE. */
139 get_parent_with_private_access (tree decl
, tree binfo
)
141 /* Only BINFOs should come through here. */
142 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
144 tree base_binfo
= NULL_TREE
;
146 /* Iterate through immediate parent classes. */
147 for (int i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
149 /* This parent had private access. Therefore that's why BINFO can't
151 if (access_in_type (BINFO_TYPE (base_binfo
), decl
) == ak_private
)
155 /* None of the parents had access. Note: it's impossible for one of the
156 parents to have had public or protected access to DECL, since then
157 BINFO would have been able to access DECL too. */
161 /* Returns true if type BASE is accessible in T. (BASE is known to be
162 a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
163 true, consider any special access of the current scope, or access
164 bestowed by friendship. */
167 accessible_base_p (tree t
, tree base
, bool consider_local_p
)
171 /* [class.access.base]
173 A base class is said to be accessible if an invented public
174 member of the base class is accessible.
176 If BASE is a non-proper base, this condition is trivially
178 if (same_type_p (t
, base
))
180 /* Rather than inventing a public member, we use the implicit
181 public typedef created in the scope of every class. */
182 decl
= TYPE_FIELDS (base
);
183 while (!DECL_SELF_REFERENCE_P (decl
))
184 decl
= DECL_CHAIN (decl
);
185 while (ANON_AGGR_TYPE_P (t
))
186 t
= TYPE_CONTEXT (t
);
187 return accessible_p (t
, decl
, consider_local_p
);
190 /* Lookup BASE in the hierarchy dominated by T. Do access checking as
191 ACCESS specifies. Return the binfo we discover. If KIND_PTR is
192 non-NULL, fill with information about what kind of base we
195 If the base is inaccessible, or ambiguous, then error_mark_node is
196 returned. If the tf_error bit of COMPLAIN is not set, no error
200 lookup_base (tree t
, tree base
, base_access access
,
201 base_kind
*kind_ptr
, tsubst_flags_t complain
)
207 /* "Nothing" is definitely not derived from Base. */
211 *kind_ptr
= bk_not_base
;
215 if (t
== error_mark_node
|| base
== error_mark_node
)
218 *kind_ptr
= bk_not_base
;
219 return error_mark_node
;
221 gcc_assert (TYPE_P (base
));
230 t
= complete_type (TYPE_MAIN_VARIANT (t
));
231 if (dependent_type_p (t
))
232 if (tree open
= currently_open_class (t
))
234 t_binfo
= TYPE_BINFO (t
);
237 base
= TYPE_MAIN_VARIANT (base
);
239 /* If BASE is incomplete, it can't be a base of T--and instantiating it
240 might cause an error. */
241 if (t_binfo
&& CLASS_TYPE_P (base
) && COMPLETE_OR_OPEN_TYPE_P (base
))
243 struct lookup_base_data_s data
;
247 data
.binfo
= NULL_TREE
;
248 data
.ambiguous
= data
.via_virtual
= false;
249 data
.repeated_base
= CLASSTYPE_REPEATED_BASE_P (t
);
250 data
.want_any
= access
== ba_any
;
252 dfs_walk_once (t_binfo
, dfs_lookup_base
, NULL
, &data
);
256 bk
= data
.ambiguous
? bk_ambig
: bk_not_base
;
257 else if (binfo
== t_binfo
)
259 else if (data
.via_virtual
)
270 /* Check that the base is unambiguous and accessible. */
271 if (access
!= ba_any
)
278 if (complain
& tf_error
)
279 error ("%qT is an ambiguous base of %qT", base
, t
);
280 binfo
= error_mark_node
;
284 if ((access
& ba_check_bit
)
285 /* If BASE is incomplete, then BASE and TYPE are probably
286 the same, in which case BASE is accessible. If they
287 are not the same, then TYPE is invalid. In that case,
288 there's no need to issue another error here, and
289 there's no implicit typedef to use in the code that
290 follows, so we skip the check. */
291 && COMPLETE_TYPE_P (base
)
292 && !accessible_base_p (t
, base
, !(access
& ba_ignore_scope
)))
294 if (complain
& tf_error
)
295 error ("%qT is an inaccessible base of %qT", base
, t
);
296 binfo
= error_mark_node
;
297 bk
= bk_inaccessible
;
308 /* Data for dcast_base_hint walker. */
312 tree subtype
; /* The base type we're looking for. */
313 int virt_depth
; /* Number of virtual bases encountered from most
315 tree offset
; /* Best hint offset discovered so far. */
316 bool repeated_base
; /* Whether there are repeated bases in the
320 /* Worker for dcast_base_hint. Search for the base type being cast
324 dfs_dcast_hint_pre (tree binfo
, void *data_
)
326 struct dcast_data_s
*data
= (struct dcast_data_s
*) data_
;
328 if (BINFO_VIRTUAL_P (binfo
))
331 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->subtype
))
333 if (data
->virt_depth
)
335 data
->offset
= ssize_int (-1);
339 data
->offset
= ssize_int (-3);
341 data
->offset
= BINFO_OFFSET (binfo
);
343 return data
->repeated_base
? dfs_skip_bases
: data
->offset
;
349 /* Worker for dcast_base_hint. Track the virtual depth. */
352 dfs_dcast_hint_post (tree binfo
, void *data_
)
354 struct dcast_data_s
*data
= (struct dcast_data_s
*) data_
;
356 if (BINFO_VIRTUAL_P (binfo
))
362 /* The dynamic cast runtime needs a hint about how the static SUBTYPE type
363 started from is related to the required TARGET type, in order to optimize
364 the inheritance graph search. This information is independent of the
365 current context, and ignores private paths, hence get_base_distance is
366 inappropriate. Return a TREE specifying the base offset, BOFF.
367 BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
368 and there are no public virtual SUBTYPE bases.
369 BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
370 BOFF == -2, SUBTYPE is not a public base.
371 BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
374 dcast_base_hint (tree subtype
, tree target
)
376 struct dcast_data_s data
;
378 data
.subtype
= subtype
;
380 data
.offset
= NULL_TREE
;
381 data
.repeated_base
= CLASSTYPE_REPEATED_BASE_P (target
);
383 dfs_walk_once_accessible (TYPE_BINFO (target
), /*friends=*/false,
384 dfs_dcast_hint_pre
, dfs_dcast_hint_post
, &data
);
385 return data
.offset
? data
.offset
: ssize_int (-2);
388 /* Search for a member with name NAME in a multiple inheritance
389 lattice specified by TYPE. If it does not exist, return NULL_TREE.
390 If the member is ambiguously referenced, return `error_mark_node'.
391 Otherwise, return a DECL with the indicated name. If WANT_TYPE is
392 true, type declarations are preferred. */
394 /* Return the FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, or
395 NAMESPACE_DECL corresponding to the innermost non-block scope. */
400 /* There are a number of cases we need to be aware of here:
401 current_class_type current_function_decl
408 Those last two make life interesting. If we're in a function which is
409 itself inside a class, we need decls to go into the fn's decls (our
410 second case below). But if we're in a class and the class itself is
411 inside a function, we need decls to go into the decls for the class. To
412 achieve this last goal, we must see if, when both current_class_ptr and
413 current_function_decl are set, the class was declared inside that
414 function. If so, we know to put the decls into the class's scope. */
415 if (current_function_decl
&& current_class_type
416 && ((DECL_FUNCTION_MEMBER_P (current_function_decl
)
417 && same_type_p (DECL_CONTEXT (current_function_decl
),
419 || (DECL_FRIEND_CONTEXT (current_function_decl
)
420 && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl
),
421 current_class_type
))))
422 return current_function_decl
;
424 if (current_class_type
)
425 return current_class_type
;
427 if (current_function_decl
)
428 return current_function_decl
;
430 return current_namespace
;
433 /* Returns nonzero if we are currently in a function scope. Note
434 that this function returns zero if we are within a local class, but
435 not within a member function body of the local class. */
438 at_function_scope_p (void)
440 tree cs
= current_scope ();
441 /* Also check cfun to make sure that we're really compiling
442 this function (as opposed to having set current_function_decl
443 for access checking or some such). */
444 return (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
445 && cfun
&& cfun
->decl
== current_function_decl
);
448 /* Returns true if the innermost active scope is a class scope. */
451 at_class_scope_p (void)
453 tree cs
= current_scope ();
454 return cs
&& TYPE_P (cs
);
457 /* Returns true if the innermost active scope is a namespace scope. */
460 at_namespace_scope_p (void)
462 tree cs
= current_scope ();
463 return cs
&& TREE_CODE (cs
) == NAMESPACE_DECL
;
466 /* Return the scope of DECL, as appropriate when doing name-lookup. */
469 context_for_name_lookup (tree decl
)
473 For the purposes of name lookup, after the anonymous union
474 definition, the members of the anonymous union are considered to
475 have been defined in the scope in which the anonymous union is
477 tree context
= DECL_CONTEXT (decl
);
479 while (context
&& TYPE_P (context
)
480 && (ANON_AGGR_TYPE_P (context
) || UNSCOPED_ENUM_P (context
)))
481 context
= TYPE_CONTEXT (context
);
483 context
= global_namespace
;
488 /* Returns true iff DECL is declared in TYPE. */
491 member_declared_in_type (tree decl
, tree type
)
493 /* A normal declaration obviously counts. */
494 if (context_for_name_lookup (decl
) == type
)
496 /* So does a using or access declaration. */
497 if (DECL_LANG_SPECIFIC (decl
) && !DECL_DISCRIMINATOR_P (decl
)
498 && purpose_member (type
, DECL_ACCESS (decl
)))
503 /* The accessibility routines use BINFO_ACCESS for scratch space
504 during the computation of the accessibility of some declaration. */
506 /* Avoid walking up past a declaration of the member. */
509 dfs_access_in_type_pre (tree binfo
, void *data
)
511 tree decl
= (tree
) data
;
512 tree type
= BINFO_TYPE (binfo
);
513 if (member_declared_in_type (decl
, type
))
514 return dfs_skip_bases
;
518 #define BINFO_ACCESS(NODE) \
519 ((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE)))
521 /* Set the access associated with NODE to ACCESS. */
523 #define SET_BINFO_ACCESS(NODE, ACCESS) \
524 ((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \
525 (TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0))
527 /* Called from access_in_type via dfs_walk. Calculate the access to
528 DATA (which is really a DECL) in BINFO. */
531 dfs_access_in_type (tree binfo
, void *data
)
533 tree decl
= (tree
) data
;
534 tree type
= BINFO_TYPE (binfo
);
535 access_kind access
= ak_none
;
537 if (context_for_name_lookup (decl
) == type
)
539 /* If we have descended to the scope of DECL, just note the
540 appropriate access. */
541 if (TREE_PRIVATE (decl
))
543 else if (TREE_PROTECTED (decl
))
544 access
= ak_protected
;
550 /* First, check for an access-declaration that gives us more
551 access to the DECL. */
552 if (DECL_LANG_SPECIFIC (decl
) && !DECL_DISCRIMINATOR_P (decl
))
554 tree decl_access
= purpose_member (type
, DECL_ACCESS (decl
));
558 decl_access
= TREE_VALUE (decl_access
);
560 if (decl_access
== access_public_node
)
562 else if (decl_access
== access_protected_node
)
563 access
= ak_protected
;
564 else if (decl_access
== access_private_node
)
575 vec
<tree
, va_gc
> *accesses
;
577 /* Otherwise, scan our baseclasses, and pick the most favorable
579 accesses
= BINFO_BASE_ACCESSES (binfo
);
580 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
582 tree base_access
= (*accesses
)[i
];
583 access_kind base_access_now
= BINFO_ACCESS (base_binfo
);
585 if (base_access_now
== ak_none
|| base_access_now
== ak_private
)
586 /* If it was not accessible in the base, or only
587 accessible as a private member, we can't access it
589 base_access_now
= ak_none
;
590 else if (base_access
== access_protected_node
)
591 /* Public and protected members in the base become
593 base_access_now
= ak_protected
;
594 else if (base_access
== access_private_node
)
595 /* Public and protected members in the base become
597 base_access_now
= ak_private
;
599 /* See if the new access, via this base, gives more
600 access than our previous best access. */
601 if (base_access_now
!= ak_none
602 && (access
== ak_none
|| base_access_now
< access
))
604 access
= base_access_now
;
606 /* If the new access is public, we can't do better. */
607 if (access
== ak_public
)
614 /* Note the access to DECL in TYPE. */
615 SET_BINFO_ACCESS (binfo
, access
);
620 /* Return the access to DECL in TYPE. */
623 access_in_type (tree type
, tree decl
)
625 tree binfo
= TYPE_BINFO (type
);
627 /* We must take into account
631 If a name can be reached by several paths through a multiple
632 inheritance graph, the access is that of the path that gives
635 The algorithm we use is to make a post-order depth-first traversal
636 of the base-class hierarchy. As we come up the tree, we annotate
637 each node with the most lenient access. */
638 dfs_walk_once (binfo
, dfs_access_in_type_pre
, dfs_access_in_type
, decl
);
640 return BINFO_ACCESS (binfo
);
643 /* Returns nonzero if it is OK to access DECL named in TYPE through an object
644 of OTYPE in the context of DERIVED. */
647 protected_accessible_p (tree decl
, tree derived
, tree type
, tree otype
)
649 /* We're checking this clause from [class.access.base]
651 m as a member of N is protected, and the reference occurs in a
652 member or friend of class N, or in a member or friend of a
653 class P derived from N, where m as a member of P is public, private
656 Here DERIVED is a possible P, DECL is m and TYPE is N. */
658 /* If DERIVED isn't derived from N, then it can't be a P. */
659 if (!DERIVED_FROM_P (type
, derived
))
662 /* DECL_NONSTATIC_MEMBER_P won't work for USING_DECLs. */
663 decl
= strip_using_decl (decl
);
664 /* We don't expect or support dependent decls. */
665 gcc_assert (TREE_CODE (decl
) != USING_DECL
);
669 When a friend or a member function of a derived class references
670 a protected non-static member of a base class, an access check
671 applies in addition to those described earlier in clause
672 _class.access_) Except when forming a pointer to member
673 (_expr.unary.op_), the access must be through a pointer to,
674 reference to, or object of the derived class itself (or any class
675 derived from that class) (_expr.ref_). If the access is to form
676 a pointer to member, the nested-name-specifier shall name the
677 derived class (or any class derived from that class). */
678 if (DECL_NONSTATIC_MEMBER_P (decl
)
679 && !DERIVED_FROM_P (derived
, otype
))
685 /* Returns nonzero if SCOPE is a type or a friend of a type which would be able
686 to access DECL through TYPE. OTYPE is the type of the object. */
689 friend_accessible_p (tree scope
, tree decl
, tree type
, tree otype
)
691 /* We're checking this clause from [class.access.base]
693 m as a member of N is protected, and the reference occurs in a
694 member or friend of class N, or in a member or friend of a
695 class P derived from N, where m as a member of P is public, private
698 Here DECL is m and TYPE is N. SCOPE is the current context,
699 and we check all its possible Ps. */
700 tree befriending_classes
;
706 if (is_global_friend (scope
))
709 /* Is SCOPE itself a suitable P? */
710 if (TYPE_P (scope
) && protected_accessible_p (decl
, scope
, type
, otype
))
713 if (DECL_DECLARES_FUNCTION_P (scope
))
714 befriending_classes
= DECL_BEFRIENDING_CLASSES (scope
);
715 else if (TYPE_P (scope
))
716 befriending_classes
= CLASSTYPE_BEFRIENDING_CLASSES (scope
);
720 for (t
= befriending_classes
; t
; t
= TREE_CHAIN (t
))
721 if (protected_accessible_p (decl
, TREE_VALUE (t
), type
, otype
))
724 /* Nested classes have the same access as their enclosing types, as
725 per DR 45 (this is a change from C++98). */
727 if (friend_accessible_p (TYPE_CONTEXT (scope
), decl
, type
, otype
))
730 if (DECL_DECLARES_FUNCTION_P (scope
))
732 /* Perhaps this SCOPE is a member of a class which is a
734 if (DECL_CLASS_SCOPE_P (scope
)
735 && friend_accessible_p (DECL_CONTEXT (scope
), decl
, type
, otype
))
737 /* Perhaps SCOPE is a friend function defined inside a class from which
738 DECL is accessible. */
739 if (tree fctx
= DECL_FRIEND_CONTEXT (scope
))
740 if (friend_accessible_p (fctx
, decl
, type
, otype
))
744 /* Maybe scope's template is a friend. */
745 if (tree tinfo
= get_template_info (scope
))
747 tree tmpl
= TI_TEMPLATE (tinfo
);
748 if (DECL_CLASS_TEMPLATE_P (tmpl
))
749 tmpl
= TREE_TYPE (tmpl
);
751 tmpl
= DECL_TEMPLATE_RESULT (tmpl
);
754 /* Increment processing_template_decl to make sure that
755 dependent_type_p works correctly. */
756 ++processing_template_decl
;
757 int ret
= friend_accessible_p (tmpl
, decl
, type
, otype
);
758 --processing_template_decl
;
764 /* If is_friend is true, we should have found a befriending class. */
765 gcc_checking_assert (!is_friend (type
, scope
));
770 struct dfs_accessible_data
776 /* Avoid walking up past a declaration of the member. */
779 dfs_accessible_pre (tree binfo
, void *data
)
781 dfs_accessible_data
*d
= (dfs_accessible_data
*)data
;
782 tree type
= BINFO_TYPE (binfo
);
783 if (member_declared_in_type (d
->decl
, type
))
784 return dfs_skip_bases
;
788 /* Called via dfs_walk_once_accessible from accessible_p */
791 dfs_accessible_post (tree binfo
, void *data
)
793 /* access_in_type already set BINFO_ACCESS for us. */
794 access_kind access
= BINFO_ACCESS (binfo
);
795 tree N
= BINFO_TYPE (binfo
);
796 dfs_accessible_data
*d
= (dfs_accessible_data
*)data
;
798 tree scope
= current_nonlambda_scope ();
800 /* A member m is accessible at the point R when named in class N if */
807 /* m as a member of N is public, or */
812 /* m as a member of N is private, and R occurs in a member or friend of
814 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
815 && is_friend (N
, scope
))
822 /* m as a member of N is protected, and R occurs in a member or friend
823 of class N, or in a member or friend of a class P derived from N,
824 where m as a member of P is public, private, or protected */
825 if (friend_accessible_p (scope
, decl
, N
, d
->object_type
))
835 /* Like accessible_p below, but within a template returns true iff DECL is
836 accessible in TYPE to all possible instantiations of the template. */
839 accessible_in_template_p (tree type
, tree decl
)
841 int save_ptd
= processing_template_decl
;
842 processing_template_decl
= 0;
843 int val
= accessible_p (type
, decl
, false);
844 processing_template_decl
= save_ptd
;
848 /* DECL is a declaration from a base class of TYPE, which was the
849 class used to name DECL. Return nonzero if, in the current
850 context, DECL is accessible. If TYPE is actually a BINFO node,
851 then we can tell in what context the access is occurring by looking
852 at the most derived class along the path indicated by BINFO. If
853 CONSIDER_LOCAL is true, do consider special access the current
854 scope or friendship thereof we might have. */
857 accessible_p (tree type
, tree decl
, bool consider_local_p
)
862 /* If this declaration is in a block or namespace scope, there's no
864 if (!TYPE_P (context_for_name_lookup (decl
)))
867 /* There is no need to perform access checks inside a thunk. */
868 if (current_function_decl
&& DECL_THUNK_P (current_function_decl
))
871 tree otype
= NULL_TREE
;
874 /* When accessing a non-static member, the most derived type in the
875 binfo chain is the type of the object; remember that type for
876 protected_accessible_p. */
877 for (tree b
= type
; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
878 otype
= BINFO_TYPE (b
);
879 type
= BINFO_TYPE (type
);
884 /* [class.access.base]
886 A member m is accessible when named in class N if
888 --m as a member of N is public, or
890 --m as a member of N is private, and the reference occurs in a
891 member or friend of class N, or
893 --m as a member of N is protected, and the reference occurs in a
894 member or friend of class N, or in a member or friend of a
895 class P derived from N, where m as a member of P is public, private or
898 --there exists a base class B of N that is accessible at the point
899 of reference, and m is accessible when named in class B.
901 We walk the base class hierarchy, checking these conditions. */
903 /* We walk using TYPE_BINFO (type) because access_in_type will set
904 BINFO_ACCESS on it and its bases. */
905 binfo
= TYPE_BINFO (type
);
907 /* Compute the accessibility of DECL in the class hierarchy
908 dominated by type. */
909 access
= access_in_type (type
, decl
);
910 if (access
== ak_public
)
913 /* If we aren't considering the point of reference, only the first bullet
915 if (!consider_local_p
)
918 dfs_accessible_data d
= { decl
, otype
};
920 /* Walk the hierarchy again, looking for a base class that allows
922 return dfs_walk_once_accessible (binfo
, /*friends=*/true,
924 dfs_accessible_post
, &d
)
928 struct lookup_field_info
{
929 /* The type in which we're looking. */
931 /* The name of the field for which we're looking. */
933 /* If non-NULL, the current result of the lookup. */
935 /* The path to RVAL. */
937 /* If non-NULL, the lookup was ambiguous, and this is a list of the
940 /* If nonzero, we are looking for types, not data members. */
944 /* True for a class member means that it is shared between all objects
947 [class.member.lookup]:If the resulting set of declarations are not all
948 from sub-objects of the same type, or the set has a non-static member
949 and includes members from distinct sub-objects, there is an ambiguity
950 and the program is ill-formed.
952 This function checks that T contains no non-static members. */
955 shared_member_p (tree t
)
957 if (VAR_P (t
) || TREE_CODE (t
) == TYPE_DECL
958 || TREE_CODE (t
) == CONST_DECL
)
960 if (is_overloaded_fn (t
))
962 for (ovl_iterator
iter (get_fns (t
)); iter
; ++iter
)
964 tree decl
= strip_using_decl (*iter
);
965 if (TREE_CODE (decl
) == USING_DECL
)
966 /* Conservatively assume a dependent using-declaration
967 might resolve to a non-static member. */
969 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
977 /* Routine to see if the sub-object denoted by the binfo PARENT can be
978 found as a base class and sub-object of the object denoted by
982 is_subobject_of_p (tree parent
, tree binfo
)
986 for (probe
= parent
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
990 if (BINFO_VIRTUAL_P (probe
))
991 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (binfo
))
997 /* DATA is really a struct lookup_field_info. Look for a field with
998 the name indicated there in BINFO. If this function returns a
999 non-NULL value it is the result of the lookup. Called from
1000 lookup_field via breadth_first_search. */
1003 lookup_field_r (tree binfo
, void *data
)
1005 struct lookup_field_info
*lfi
= (struct lookup_field_info
*) data
;
1006 tree type
= BINFO_TYPE (binfo
);
1007 tree nval
= NULL_TREE
;
1009 /* If this is a dependent base, don't look in it. */
1010 if (BINFO_DEPENDENT_BASE_P (binfo
))
1013 /* If this base class is hidden by the best-known value so far, we
1014 don't need to look. */
1015 if (lfi
->rval_binfo
&& BINFO_INHERITANCE_CHAIN (binfo
) == lfi
->rval_binfo
1016 && !BINFO_VIRTUAL_P (binfo
))
1017 return dfs_skip_bases
;
1019 nval
= get_class_binding (type
, lfi
->name
, lfi
->want_type
);
1021 /* If there is no declaration with the indicated name in this type,
1022 then there's nothing to do. */
1026 /* If the lookup already found a match, and the new value doesn't
1027 hide the old one, we might have an ambiguity. */
1029 && !is_subobject_of_p (lfi
->rval_binfo
, binfo
))
1032 if (nval
== lfi
->rval
&& shared_member_p (nval
))
1033 /* The two things are really the same. */
1035 else if (is_subobject_of_p (binfo
, lfi
->rval_binfo
))
1036 /* The previous value hides the new one. */
1040 /* We have a real ambiguity. We keep a chain of all the
1042 if (!lfi
->ambiguous
&& lfi
->rval
)
1044 /* This is the first time we noticed an ambiguity. Add
1045 what we previously thought was a reasonable candidate
1047 lfi
->ambiguous
= tree_cons (NULL_TREE
, lfi
->rval
, NULL_TREE
);
1048 TREE_TYPE (lfi
->ambiguous
) = error_mark_node
;
1051 /* Add the new value. */
1052 lfi
->ambiguous
= tree_cons (NULL_TREE
, nval
, lfi
->ambiguous
);
1053 TREE_TYPE (lfi
->ambiguous
) = error_mark_node
;
1059 lfi
->rval_binfo
= binfo
;
1063 /* Don't look for constructors or destructors in base classes. */
1064 if (IDENTIFIER_CDTOR_P (lfi
->name
))
1065 return dfs_skip_bases
;
1069 /* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO,
1070 BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO,
1071 FUNCTIONS, and OPTYPE respectively. */
1074 build_baselink (tree binfo
, tree access_binfo
, tree functions
, tree optype
)
1078 gcc_assert (OVL_P (functions
) || TREE_CODE (functions
) == TEMPLATE_ID_EXPR
);
1079 gcc_assert (!optype
|| TYPE_P (optype
));
1080 gcc_assert (TREE_TYPE (functions
));
1082 baselink
= make_node (BASELINK
);
1083 TREE_TYPE (baselink
) = TREE_TYPE (functions
);
1084 BASELINK_BINFO (baselink
) = binfo
;
1085 BASELINK_ACCESS_BINFO (baselink
) = access_binfo
;
1086 BASELINK_FUNCTIONS (baselink
) = functions
;
1087 BASELINK_OPTYPE (baselink
) = optype
;
1089 if (binfo
== access_binfo
1090 && TYPE_BEING_DEFINED (BINFO_TYPE (access_binfo
)))
1091 BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P (baselink
) = true;
1096 /* Look for a member named NAME in an inheritance lattice dominated by
1097 XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
1098 is 1, we enforce accessibility. If PROTECT is zero, then, for an
1099 ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
1100 messages about inaccessible or ambiguous lookup. If PROTECT is 2,
1101 we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
1102 TREE_VALUEs are the list of ambiguous candidates.
1104 WANT_TYPE is 1 when we should only return TYPE_DECLs.
1106 If nothing can be found return NULL_TREE and do not issue an error.
1108 If non-NULL, failure information is written back to AFI. */
1111 lookup_member (tree xbasetype
, tree name
, int protect
, bool want_type
,
1112 tsubst_flags_t complain
, access_failure_info
*afi
)
1114 tree rval
, rval_binfo
= NULL_TREE
;
1115 tree type
= NULL_TREE
, basetype_path
= NULL_TREE
;
1116 struct lookup_field_info lfi
;
1118 /* rval_binfo is the binfo associated with the found member, note,
1119 this can be set with useful information, even when rval is not
1120 set, because it must deal with ALL members, not just non-function
1121 members. It is used for ambiguity checking and the hidden
1122 checks. Whereas rval is only set if a proper (not hidden)
1123 non-function member is found. */
1125 if (name
== error_mark_node
1126 || xbasetype
== NULL_TREE
1127 || xbasetype
== error_mark_node
)
1130 gcc_assert (identifier_p (name
));
1132 if (TREE_CODE (xbasetype
) == TREE_BINFO
)
1134 type
= BINFO_TYPE (xbasetype
);
1135 basetype_path
= xbasetype
;
1139 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype
)))
1142 xbasetype
= NULL_TREE
;
1145 type
= complete_type (type
);
1147 /* Make sure we're looking for a member of the current instantiation in the
1148 right partial specialization. */
1149 if (dependent_type_p (type
))
1150 if (tree t
= currently_open_class (type
))
1154 basetype_path
= TYPE_BINFO (type
);
1159 memset (&lfi
, 0, sizeof (lfi
));
1162 lfi
.want_type
= want_type
;
1163 dfs_walk_all (basetype_path
, &lookup_field_r
, NULL
, &lfi
);
1165 rval_binfo
= lfi
.rval_binfo
;
1167 type
= BINFO_TYPE (rval_binfo
);
1173 else if (protect
== 1)
1175 if (complain
& tf_error
)
1177 error ("request for member %qD is ambiguous", name
);
1178 print_candidates (lfi
.ambiguous
);
1180 return error_mark_node
;
1182 else if (protect
== 2)
1183 return lfi
.ambiguous
;
1191 In the case of overloaded function names, access control is
1192 applied to the function selected by overloaded resolution.
1194 We cannot check here, even if RVAL is only a single non-static
1195 member function, since we do not know what the "this" pointer
1198 class A { protected: void f(); };
1199 class B : public A {
1206 only the first call to "f" is valid. However, if the function is
1207 static, we can check. */
1208 if (protect
== 1 && !really_overloaded_fn (rval
))
1210 tree decl
= is_overloaded_fn (rval
) ? get_first_fn (rval
) : rval
;
1211 decl
= strip_using_decl (decl
);
1212 /* A dependent USING_DECL will be checked after tsubsting. */
1213 if (TREE_CODE (decl
) != USING_DECL
1214 && !DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
)
1215 && !perform_or_defer_access_check (basetype_path
, decl
, decl
,
1217 return error_mark_node
;
1220 if (is_overloaded_fn (rval
)
1221 /* Don't use a BASELINK for class-scope deduction guides since
1222 they're not actually member functions. */
1223 && !dguide_name_p (name
))
1224 rval
= build_baselink (rval_binfo
, basetype_path
, rval
,
1225 (IDENTIFIER_CONV_OP_P (name
)
1226 ? TREE_TYPE (name
): NULL_TREE
));
1230 /* Helper class for lookup_member_fuzzy. */
1232 class lookup_field_fuzzy_info
1235 lookup_field_fuzzy_info (bool want_type_p
) :
1236 m_want_type_p (want_type_p
), m_candidates () {}
1238 void fuzzy_lookup_field (tree type
);
1240 /* If true, we are looking for types, not data members. */
1242 /* The result: a vec of identifiers. */
1243 auto_vec
<tree
> m_candidates
;
1246 /* Locate all fields within TYPE, append them to m_candidates. */
1249 lookup_field_fuzzy_info::fuzzy_lookup_field (tree type
)
1251 if (!CLASS_TYPE_P (type
))
1254 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1256 if (m_want_type_p
&& !DECL_DECLARES_TYPE_P (field
))
1259 if (!DECL_NAME (field
))
1262 if (is_lambda_ignored_entity (field
))
1265 /* Ignore special identifiers with space at the end like cdtor or
1266 conversion op identifiers. */
1267 if (TREE_CODE (DECL_NAME (field
)) == IDENTIFIER_NODE
)
1268 if (unsigned int len
= IDENTIFIER_LENGTH (DECL_NAME (field
)))
1269 if (IDENTIFIER_POINTER (DECL_NAME (field
))[len
- 1] == ' ')
1272 m_candidates
.safe_push (DECL_NAME (field
));
1277 /* Helper function for lookup_member_fuzzy, called via dfs_walk_all
1278 DATA is really a lookup_field_fuzzy_info. Look for a field with
1279 the name indicated there in BINFO. Gathers pertinent identifiers into
1283 lookup_field_fuzzy_r (tree binfo
, void *data
)
1285 lookup_field_fuzzy_info
*lffi
= (lookup_field_fuzzy_info
*) data
;
1286 tree type
= BINFO_TYPE (binfo
);
1288 lffi
->fuzzy_lookup_field (type
);
1293 /* Like lookup_member, but try to find the closest match for NAME,
1294 rather than an exact match, and return an identifier (or NULL_TREE).
1298 lookup_member_fuzzy (tree xbasetype
, tree name
, bool want_type_p
)
1300 tree type
= NULL_TREE
, basetype_path
= NULL_TREE
;
1301 class lookup_field_fuzzy_info
lffi (want_type_p
);
1303 /* rval_binfo is the binfo associated with the found member, note,
1304 this can be set with useful information, even when rval is not
1305 set, because it must deal with ALL members, not just non-function
1306 members. It is used for ambiguity checking and the hidden
1307 checks. Whereas rval is only set if a proper (not hidden)
1308 non-function member is found. */
1310 if (name
== error_mark_node
1311 || xbasetype
== NULL_TREE
1312 || xbasetype
== error_mark_node
)
1315 gcc_assert (identifier_p (name
));
1317 if (TREE_CODE (xbasetype
) == TREE_BINFO
)
1319 type
= BINFO_TYPE (xbasetype
);
1320 basetype_path
= xbasetype
;
1324 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype
)))
1327 xbasetype
= NULL_TREE
;
1330 type
= complete_type (type
);
1332 /* Make sure we're looking for a member of the current instantiation in the
1333 right partial specialization. */
1334 if (flag_concepts
&& dependent_type_p (type
))
1335 type
= currently_open_class (type
);
1338 basetype_path
= TYPE_BINFO (type
);
1343 /* Populate lffi.m_candidates. */
1344 dfs_walk_all (basetype_path
, &lookup_field_fuzzy_r
, NULL
, &lffi
);
1346 return find_closest_identifier (name
, &lffi
.m_candidates
);
1349 /* Like lookup_member, except that if we find a function member we
1350 return NULL_TREE. */
1353 lookup_field (tree xbasetype
, tree name
, int protect
, bool want_type
)
1355 tree rval
= lookup_member (xbasetype
, name
, protect
, want_type
,
1356 tf_warning_or_error
);
1358 /* Ignore functions, but propagate the ambiguity list. */
1359 if (!error_operand_p (rval
)
1360 && (rval
&& BASELINK_P (rval
)))
1366 /* Like lookup_member, except that if we find a non-function member we
1367 return NULL_TREE. */
1370 lookup_fnfields (tree xbasetype
, tree name
, int protect
,
1371 tsubst_flags_t complain
)
1373 tree rval
= lookup_member (xbasetype
, name
, protect
, /*want_type=*/false,
1376 /* Ignore non-functions, but propagate the ambiguity list. */
1377 if (!error_operand_p (rval
)
1378 && (rval
&& !BASELINK_P (rval
)))
1384 /* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
1385 the class or namespace used to qualify the name. CONTEXT_CLASS is
1386 the class corresponding to the object in which DECL will be used.
1387 Return a possibly modified version of DECL that takes into account
1390 In particular, consider an expression like `B::m' in the context of
1391 a derived class `D'. If `B::m' has been resolved to a BASELINK,
1392 then the most derived class indicated by the BASELINK_BINFO will be
1393 `B', not `D'. This function makes that adjustment. */
1396 adjust_result_of_qualified_name_lookup (tree decl
,
1397 tree qualifying_scope
,
1400 if (context_class
&& context_class
!= error_mark_node
1401 && CLASS_TYPE_P (context_class
)
1402 && CLASS_TYPE_P (qualifying_scope
)
1403 && DERIVED_FROM_P (qualifying_scope
, context_class
)
1404 && BASELINK_P (decl
))
1408 /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
1409 Because we do not yet know which function will be chosen by
1410 overload resolution, we cannot yet check either accessibility
1411 or ambiguity -- in either case, the choice of a static member
1412 function might make the usage valid. */
1413 base
= lookup_base (context_class
, qualifying_scope
,
1414 ba_unique
, NULL
, tf_none
);
1415 if (base
&& base
!= error_mark_node
)
1417 BASELINK_ACCESS_BINFO (decl
) = base
;
1419 = lookup_base (base
, BINFO_TYPE (BASELINK_BINFO (decl
)),
1420 ba_unique
, NULL
, tf_none
);
1421 if (decl_binfo
&& decl_binfo
!= error_mark_node
)
1422 BASELINK_BINFO (decl
) = decl_binfo
;
1426 if (BASELINK_P (decl
))
1427 BASELINK_QUALIFIED_P (decl
) = true;
1433 /* Walk the class hierarchy within BINFO, in a depth-first traversal.
1434 PRE_FN is called in preorder, while POST_FN is called in postorder.
1435 If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
1436 walked. If PRE_FN or POST_FN returns a different non-NULL value,
1437 that value is immediately returned and the walk is terminated. One
1438 of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
1439 POST_FN are passed the binfo to examine and the caller's DATA
1440 value. All paths are walked, thus virtual and morally virtual
1441 binfos can be multiply walked. */
1444 dfs_walk_all (tree binfo
, tree (*pre_fn
) (tree
, void *),
1445 tree (*post_fn
) (tree
, void *), void *data
)
1451 /* Call the pre-order walking function. */
1454 rval
= pre_fn (binfo
, data
);
1457 if (rval
== dfs_skip_bases
)
1463 /* Find the next child binfo to walk. */
1464 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1466 rval
= dfs_walk_all (base_binfo
, pre_fn
, post_fn
, data
);
1472 /* Call the post-order walking function. */
1475 rval
= post_fn (binfo
, data
);
1476 gcc_assert (rval
!= dfs_skip_bases
);
1483 /* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1484 that binfos are walked at most once. */
1487 dfs_walk_once_r (tree binfo
, tree (*pre_fn
) (tree
, void *),
1488 tree (*post_fn
) (tree
, void *), hash_set
<tree
> *pset
,
1495 /* Call the pre-order walking function. */
1498 rval
= pre_fn (binfo
, data
);
1501 if (rval
== dfs_skip_bases
)
1508 /* Find the next child binfo to walk. */
1509 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1511 if (BINFO_VIRTUAL_P (base_binfo
))
1512 if (pset
->add (base_binfo
))
1515 rval
= dfs_walk_once_r (base_binfo
, pre_fn
, post_fn
, pset
, data
);
1521 /* Call the post-order walking function. */
1524 rval
= post_fn (binfo
, data
);
1525 gcc_assert (rval
!= dfs_skip_bases
);
1532 /* Like dfs_walk_all, except that binfos are not multiply walked. For
1533 non-diamond shaped hierarchies this is the same as dfs_walk_all.
1534 For diamond shaped hierarchies we must mark the virtual bases, to
1535 avoid multiple walks. */
1538 dfs_walk_once (tree binfo
, tree (*pre_fn
) (tree
, void *),
1539 tree (*post_fn
) (tree
, void *), void *data
)
1541 static int active
= 0; /* We must not be called recursively. */
1544 gcc_assert (pre_fn
|| post_fn
);
1545 gcc_assert (!active
);
1548 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
)))
1549 /* We are not diamond shaped, and therefore cannot encounter the
1550 same binfo twice. */
1551 rval
= dfs_walk_all (binfo
, pre_fn
, post_fn
, data
);
1554 hash_set
<tree
> pset
;
1555 rval
= dfs_walk_once_r (binfo
, pre_fn
, post_fn
, &pset
, data
);
1563 /* Worker function for dfs_walk_once_accessible. Behaves like
1564 dfs_walk_once_r, except (a) FRIENDS_P is true if special
1565 access given by the current context should be considered, (b) ONCE
1566 indicates whether bases should be marked during traversal. */
1569 dfs_walk_once_accessible_r (tree binfo
, bool friends_p
, hash_set
<tree
> *pset
,
1570 tree (*pre_fn
) (tree
, void *),
1571 tree (*post_fn
) (tree
, void *), void *data
)
1573 tree rval
= NULL_TREE
;
1577 /* Call the pre-order walking function. */
1580 rval
= pre_fn (binfo
, data
);
1583 if (rval
== dfs_skip_bases
)
1590 /* Find the next child binfo to walk. */
1591 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1593 bool mark
= pset
&& BINFO_VIRTUAL_P (base_binfo
);
1595 if (mark
&& pset
->contains (base_binfo
))
1598 /* If the base is inherited via private or protected
1599 inheritance, then we can't see it, unless we are a friend of
1600 the current binfo. */
1601 if (BINFO_BASE_ACCESS (binfo
, ix
) != access_public_node
)
1606 scope
= current_scope ();
1608 || TREE_CODE (scope
) == NAMESPACE_DECL
1609 || !is_friend (BINFO_TYPE (binfo
), scope
))
1614 pset
->add (base_binfo
);
1616 rval
= dfs_walk_once_accessible_r (base_binfo
, friends_p
, pset
,
1617 pre_fn
, post_fn
, data
);
1623 /* Call the post-order walking function. */
1626 rval
= post_fn (binfo
, data
);
1627 gcc_assert (rval
!= dfs_skip_bases
);
1634 /* Like dfs_walk_once except that only accessible bases are walked.
1635 FRIENDS_P indicates whether friendship of the local context
1636 should be considered when determining accessibility. */
1639 dfs_walk_once_accessible (tree binfo
, bool friends_p
,
1640 tree (*pre_fn
) (tree
, void *),
1641 tree (*post_fn
) (tree
, void *), void *data
)
1643 hash_set
<tree
> *pset
= NULL
;
1644 if (CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
)))
1645 pset
= new hash_set
<tree
>;
1646 tree rval
= dfs_walk_once_accessible_r (binfo
, friends_p
, pset
,
1647 pre_fn
, post_fn
, data
);
1654 /* Return true iff the code of T is CODE, and it has compatible
1658 matches_code_and_type_p (tree t
, enum tree_code code
, tree type
)
1660 if (TREE_CODE (t
) != code
)
1662 if (!cxx_types_compatible_p (TREE_TYPE (t
), type
))
1667 /* Subroutine of direct_accessor_p and reference_accessor_p.
1668 Determine if COMPONENT_REF is a simple field lookup of this->FIELD_DECL.
1669 We expect a tree of the form:
1674 <field_decl (FIELD_DECL)>>>. */
1677 field_access_p (tree component_ref
, tree field_decl
, tree field_type
)
1679 if (!matches_code_and_type_p (component_ref
, COMPONENT_REF
, field_type
))
1682 tree indirect_ref
= TREE_OPERAND (component_ref
, 0);
1683 if (!INDIRECT_REF_P (indirect_ref
))
1686 tree ptr
= STRIP_NOPS (TREE_OPERAND (indirect_ref
, 0));
1687 if (!is_this_parameter (ptr
))
1690 /* Must access the correct field. */
1691 if (TREE_OPERAND (component_ref
, 1) != field_decl
)
1696 /* Subroutine of field_accessor_p.
1698 Assuming that INIT_EXPR has already had its code and type checked,
1699 determine if it is a simple accessor for FIELD_DECL
1700 (of type FIELD_TYPE).
1702 Specifically, a simple accessor within struct S of the form:
1703 T get_field () { return m_field; }
1704 should have a constexpr_fn_retval (saved_tree) of the form:
1712 <field_decl (FIELD_DECL)>>>>>. */
1715 direct_accessor_p (tree init_expr
, tree field_decl
, tree field_type
)
1717 tree result_decl
= TREE_OPERAND (init_expr
, 0);
1718 if (!matches_code_and_type_p (result_decl
, RESULT_DECL
, field_type
))
1721 tree component_ref
= STRIP_NOPS (TREE_OPERAND (init_expr
, 1));
1722 if (!field_access_p (component_ref
, field_decl
, field_type
))
1728 /* Subroutine of field_accessor_p.
1730 Assuming that INIT_EXPR has already had its code and type checked,
1731 determine if it is a "reference" accessor for FIELD_DECL
1732 (of type FIELD_REFERENCE_TYPE).
1734 Specifically, a simple accessor within struct S of the form:
1735 T& get_field () { return m_field; }
1736 should have a constexpr_fn_retval (saved_tree) of the form:
1745 <field (FIELD_DECL)>>>>>>. */
1747 reference_accessor_p (tree init_expr
, tree field_decl
, tree field_type
,
1748 tree field_reference_type
)
1750 tree result_decl
= TREE_OPERAND (init_expr
, 0);
1751 if (!matches_code_and_type_p (result_decl
, RESULT_DECL
, field_reference_type
))
1754 tree field_pointer_type
= build_pointer_type (field_type
);
1755 tree addr_expr
= STRIP_NOPS (TREE_OPERAND (init_expr
, 1));
1756 if (!matches_code_and_type_p (addr_expr
, ADDR_EXPR
, field_pointer_type
))
1759 tree component_ref
= STRIP_NOPS (TREE_OPERAND (addr_expr
, 0));
1761 if (!field_access_p (component_ref
, field_decl
, field_type
))
1767 /* Return true if FN is an accessor method for FIELD_DECL.
1768 i.e. a method of the form { return FIELD; }, with no
1771 If CONST_P, then additionally require that FN be a const
1775 field_accessor_p (tree fn
, tree field_decl
, bool const_p
)
1777 if (TREE_CODE (fn
) != FUNCTION_DECL
)
1780 /* We don't yet support looking up static data, just fields. */
1781 if (TREE_CODE (field_decl
) != FIELD_DECL
)
1784 tree fntype
= TREE_TYPE (fn
);
1785 if (TREE_CODE (fntype
) != METHOD_TYPE
)
1788 /* If the field is accessed via a const "this" argument, verify
1789 that the "this" parameter is const. */
1792 tree this_class
= class_of_this_parm (fntype
);
1793 if (!TYPE_READONLY (this_class
))
1797 tree saved_tree
= DECL_SAVED_TREE (fn
);
1799 if (saved_tree
== NULL_TREE
)
1802 /* Attempt to extract a single return value from the function,
1804 tree retval
= constexpr_fn_retval (saved_tree
);
1805 if (retval
== NULL_TREE
|| retval
== error_mark_node
)
1807 /* Require an INIT_EXPR. */
1808 if (TREE_CODE (retval
) != INIT_EXPR
)
1810 tree init_expr
= retval
;
1812 /* Determine if this is a simple accessor within struct S of the form:
1813 T get_field () { return m_field; }. */
1814 tree field_type
= TREE_TYPE (field_decl
);
1815 if (cxx_types_compatible_p (TREE_TYPE (init_expr
), field_type
))
1816 return direct_accessor_p (init_expr
, field_decl
, field_type
);
1818 /* Failing that, determine if it is an accessor of the form:
1819 T& get_field () { return m_field; }. */
1820 tree field_reference_type
= cp_build_reference_type (field_type
, false);
1821 if (cxx_types_compatible_p (TREE_TYPE (init_expr
), field_reference_type
))
1822 return reference_accessor_p (init_expr
, field_decl
, field_type
,
1823 field_reference_type
);
1828 /* Callback data for dfs_locate_field_accessor_pre. */
1830 class locate_field_data
1833 locate_field_data (tree field_decl_
, bool const_p_
)
1834 : field_decl (field_decl_
), const_p (const_p_
) {}
1840 /* Return a FUNCTION_DECL that is an "accessor" method for DATA, a FIELD_DECL,
1841 callable via binfo, if one exists, otherwise return NULL_TREE.
1843 Callback for dfs_walk_once_accessible for use within
1844 locate_field_accessor. */
1847 dfs_locate_field_accessor_pre (tree binfo
, void *data
)
1849 locate_field_data
*lfd
= (locate_field_data
*)data
;
1850 tree type
= BINFO_TYPE (binfo
);
1852 vec
<tree
, va_gc
> *member_vec
;
1856 if (!CLASS_TYPE_P (type
))
1859 member_vec
= CLASSTYPE_MEMBER_VEC (type
);
1863 for (i
= 0; vec_safe_iterate (member_vec
, i
, &fn
); ++i
)
1865 if (field_accessor_p (fn
, lfd
->field_decl
, lfd
->const_p
))
1871 /* Return a FUNCTION_DECL that is an "accessor" method for FIELD_DECL,
1872 callable via BASETYPE_PATH, if one exists, otherwise return NULL_TREE. */
1875 locate_field_accessor (tree basetype_path
, tree field_decl
, bool const_p
)
1877 if (TREE_CODE (basetype_path
) != TREE_BINFO
)
1880 /* Walk the hierarchy, looking for a method of some base class that allows
1881 access to the field. */
1882 locate_field_data
lfd (field_decl
, const_p
);
1883 return dfs_walk_once_accessible (basetype_path
, /*friends=*/true,
1884 dfs_locate_field_accessor_pre
,
1888 /* Check throw specifier of OVERRIDER is at least as strict as
1889 the one of BASEFN. */
1892 maybe_check_overriding_exception_spec (tree overrider
, tree basefn
)
1894 maybe_instantiate_noexcept (basefn
);
1895 maybe_instantiate_noexcept (overrider
);
1896 tree base_throw
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (basefn
));
1897 tree over_throw
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (overrider
));
1899 if (DECL_INVALID_OVERRIDER_P (overrider
))
1902 /* Can't check this yet. Pretend this is fine and let
1903 noexcept_override_late_checks check this later. */
1904 if (UNPARSED_NOEXCEPT_SPEC_P (base_throw
)
1905 || UNPARSED_NOEXCEPT_SPEC_P (over_throw
))
1908 if (!comp_except_specs (base_throw
, over_throw
, ce_derived
))
1910 auto_diagnostic_group d
;
1911 error ("looser exception specification on overriding virtual function "
1912 "%q+#F", overrider
);
1913 inform (DECL_SOURCE_LOCATION (basefn
),
1914 "overridden function is %q#F", basefn
);
1915 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
1921 /* Check that virtual overrider OVERRIDER is acceptable for base function
1922 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
1925 check_final_overrider (tree overrider
, tree basefn
)
1927 tree over_type
= TREE_TYPE (overrider
);
1928 tree base_type
= TREE_TYPE (basefn
);
1929 tree over_return
= fndecl_declared_return_type (overrider
);
1930 tree base_return
= fndecl_declared_return_type (basefn
);
1934 if (DECL_INVALID_OVERRIDER_P (overrider
))
1937 if (same_type_p (base_return
, over_return
))
1939 else if ((CLASS_TYPE_P (over_return
) && CLASS_TYPE_P (base_return
))
1940 || (TREE_CODE (base_return
) == TREE_CODE (over_return
)
1941 && INDIRECT_TYPE_P (base_return
)))
1943 /* Potentially covariant. */
1944 unsigned base_quals
, over_quals
;
1946 fail
= !INDIRECT_TYPE_P (base_return
);
1949 if (cp_type_quals (base_return
) != cp_type_quals (over_return
))
1952 if (TYPE_REF_P (base_return
)
1953 && (TYPE_REF_IS_RVALUE (base_return
)
1954 != TYPE_REF_IS_RVALUE (over_return
)))
1957 base_return
= TREE_TYPE (base_return
);
1958 over_return
= TREE_TYPE (over_return
);
1960 base_quals
= cp_type_quals (base_return
);
1961 over_quals
= cp_type_quals (over_return
);
1963 if ((base_quals
& over_quals
) != over_quals
)
1966 if (CLASS_TYPE_P (base_return
) && CLASS_TYPE_P (over_return
))
1968 /* Strictly speaking, the standard requires the return type to be
1969 complete even if it only differs in cv-quals, but that seems
1970 like a bug in the wording. */
1971 if (!same_type_ignoring_top_level_qualifiers_p (base_return
,
1974 tree binfo
= lookup_base (over_return
, base_return
,
1975 ba_check
, NULL
, tf_none
);
1977 if (!binfo
|| binfo
== error_mark_node
)
1981 else if (can_convert_standard (TREE_TYPE (base_type
),
1982 TREE_TYPE (over_type
),
1983 tf_warning_or_error
))
1984 /* GNU extension, allow trivial pointer conversions such as
1985 converting to void *, or qualification conversion. */
1987 auto_diagnostic_group d
;
1988 if (pedwarn (DECL_SOURCE_LOCATION (overrider
), 0,
1989 "invalid covariant return type for %q#D", overrider
))
1990 inform (DECL_SOURCE_LOCATION (basefn
),
1991 "overridden function is %q#D", basefn
);
2002 auto_diagnostic_group d
;
2004 error ("invalid covariant return type for %q+#D", overrider
);
2006 error ("conflicting return type specified for %q+#D", overrider
);
2007 inform (DECL_SOURCE_LOCATION (basefn
),
2008 "overridden function is %q#D", basefn
);
2009 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2013 if (!maybe_check_overriding_exception_spec (overrider
, basefn
))
2016 /* Check for conflicting type attributes. But leave transaction_safe for
2017 set_one_vmethod_tm_attributes. */
2018 if (!comp_type_attributes (over_type
, base_type
)
2019 && !tx_safe_fn_type_p (base_type
)
2020 && !tx_safe_fn_type_p (over_type
))
2022 auto_diagnostic_group d
;
2023 error ("conflicting type attributes specified for %q+#D", overrider
);
2024 inform (DECL_SOURCE_LOCATION (basefn
),
2025 "overridden function is %q#D", basefn
);
2026 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2030 /* A consteval virtual function shall not override a virtual function that is
2031 not consteval. A consteval virtual function shall not be overridden by a
2032 virtual function that is not consteval. */
2033 if (DECL_IMMEDIATE_FUNCTION_P (overrider
)
2034 != DECL_IMMEDIATE_FUNCTION_P (basefn
))
2036 auto_diagnostic_group d
;
2037 if (DECL_IMMEDIATE_FUNCTION_P (overrider
))
2038 error ("%<consteval%> function %q+D overriding non-%<consteval%> "
2039 "function", overrider
);
2041 error ("non-%<consteval%> function %q+D overriding %<consteval%> "
2042 "function", overrider
);
2043 inform (DECL_SOURCE_LOCATION (basefn
),
2044 "overridden function is %qD", basefn
);
2045 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2049 /* A function declared transaction_safe_dynamic that overrides a function
2050 declared transaction_safe (but not transaction_safe_dynamic) is
2052 if (tx_safe_fn_type_p (base_type
)
2053 && lookup_attribute ("transaction_safe_dynamic",
2054 DECL_ATTRIBUTES (overrider
))
2055 && !lookup_attribute ("transaction_safe_dynamic",
2056 DECL_ATTRIBUTES (basefn
)))
2058 auto_diagnostic_group d
;
2059 error_at (DECL_SOURCE_LOCATION (overrider
),
2060 "%qD declared %<transaction_safe_dynamic%>", overrider
);
2061 inform (DECL_SOURCE_LOCATION (basefn
),
2062 "overriding %qD declared %<transaction_safe%>", basefn
);
2065 if (DECL_DELETED_FN (basefn
) != DECL_DELETED_FN (overrider
))
2067 if (DECL_DELETED_FN (overrider
))
2069 auto_diagnostic_group d
;
2070 error ("deleted function %q+D overriding non-deleted function",
2072 inform (DECL_SOURCE_LOCATION (basefn
),
2073 "overridden function is %qD", basefn
);
2074 maybe_explain_implicit_delete (overrider
);
2078 auto_diagnostic_group d
;
2079 error ("non-deleted function %q+D overriding deleted function",
2081 inform (DECL_SOURCE_LOCATION (basefn
),
2082 "overridden function is %qD", basefn
);
2087 if (!DECL_HAS_CONTRACTS_P (basefn
) && DECL_HAS_CONTRACTS_P (overrider
))
2089 auto_diagnostic_group d
;
2090 error ("function with contracts %q+D overriding contractless function",
2092 inform (DECL_SOURCE_LOCATION (basefn
),
2093 "overridden function is %qD", basefn
);
2096 else if (DECL_HAS_CONTRACTS_P (basefn
) && !DECL_HAS_CONTRACTS_P (overrider
))
2098 /* We're inheriting basefn's contracts; create a copy of them but
2099 replace references to their parms to our parms. */
2100 inherit_base_contracts (overrider
, basefn
);
2102 else if (DECL_HAS_CONTRACTS_P (basefn
) && DECL_HAS_CONTRACTS_P (overrider
))
2104 /* We're in the process of completing the overrider's class, which means
2105 our conditions definitely are not parsed so simply chain on the
2106 basefn for later checking.
2108 Note that OVERRIDER's contracts will have been fully parsed at the
2109 point the deferred match is run. */
2110 defer_guarded_contract_match (overrider
, basefn
, DECL_CONTRACTS (basefn
));
2113 if (DECL_FINAL_P (basefn
))
2115 auto_diagnostic_group d
;
2116 error ("virtual function %q+D overriding final function", overrider
);
2117 inform (DECL_SOURCE_LOCATION (basefn
),
2118 "overridden function is %qD", basefn
);
2124 /* Given a class TYPE, and a function decl FNDECL, look for
2125 virtual functions in TYPE's hierarchy which FNDECL overrides.
2126 We do not look in TYPE itself, only its bases.
2128 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
2129 find that it overrides anything.
2131 We check that every function which is overridden, is correctly
2135 look_for_overrides (tree type
, tree fndecl
)
2137 tree binfo
= TYPE_BINFO (type
);
2142 /* A constructor for a class T does not override a function T
2144 if (DECL_CONSTRUCTOR_P (fndecl
))
2147 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2149 tree basetype
= BINFO_TYPE (base_binfo
);
2151 if (TYPE_POLYMORPHIC_P (basetype
))
2152 found
+= look_for_overrides_r (basetype
, fndecl
);
2157 /* Look in TYPE for virtual functions with the same signature as
2161 look_for_overrides_here (tree type
, tree fndecl
)
2163 tree ovl
= get_class_binding (type
, DECL_NAME (fndecl
));
2165 for (ovl_iterator
iter (ovl
); iter
; ++iter
)
2169 if (!DECL_VIRTUAL_P (fn
))
2170 /* Not a virtual. */;
2171 else if (DECL_CONTEXT (fn
) != type
)
2172 /* Introduced with a using declaration. */;
2173 else if (DECL_STATIC_FUNCTION_P (fndecl
))
2175 tree btypes
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2176 tree dtypes
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2177 if (compparms (TREE_CHAIN (btypes
), dtypes
))
2180 else if (same_signature_p (fndecl
, fn
))
2187 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
2188 TYPE itself and its bases. */
2191 look_for_overrides_r (tree type
, tree fndecl
)
2193 tree fn
= look_for_overrides_here (type
, fndecl
);
2196 if (DECL_STATIC_FUNCTION_P (fndecl
))
2198 /* A static member function cannot match an inherited
2199 virtual member function. */
2200 auto_diagnostic_group d
;
2201 error ("%q+#D cannot be declared", fndecl
);
2202 error (" since %q+#D declared in base class", fn
);
2206 /* It's definitely virtual, even if not explicitly set. */
2207 DECL_VIRTUAL_P (fndecl
) = 1;
2208 check_final_overrider (fndecl
, fn
);
2213 /* We failed to find one declared in this class. Look in its bases. */
2214 return look_for_overrides (type
, fndecl
);
2217 /* Called via dfs_walk from dfs_get_pure_virtuals. */
2220 dfs_get_pure_virtuals (tree binfo
, void *data
)
2222 tree type
= (tree
) data
;
2224 /* We're not interested in primary base classes; the derived class
2225 of which they are a primary base will contain the information we
2227 if (!BINFO_PRIMARY_P (binfo
))
2231 for (virtuals
= BINFO_VIRTUALS (binfo
);
2233 virtuals
= TREE_CHAIN (virtuals
))
2234 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals
)))
2235 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (type
), BV_FN (virtuals
));
2241 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
2244 get_pure_virtuals (tree type
)
2246 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
2247 is going to be overridden. */
2248 CLASSTYPE_PURE_VIRTUALS (type
) = NULL
;
2249 /* Now, run through all the bases which are not primary bases, and
2250 collect the pure virtual functions. We look at the vtable in
2251 each class to determine what pure virtual functions are present.
2252 (A primary base is not interesting because the derived class of
2253 which it is a primary base will contain vtable entries for the
2254 pure virtuals in the base class. */
2255 dfs_walk_once (TYPE_BINFO (type
), NULL
, dfs_get_pure_virtuals
, type
);
2258 /* Debug info for C++ classes can get very large; try to avoid
2259 emitting it everywhere.
2261 Note that this optimization wins even when the target supports
2262 BINCL (if only slightly), and reduces the amount of work for the
2266 maybe_suppress_debug_info (tree t
)
2268 if (write_symbols
== NO_DEBUG
)
2271 /* We might have set this earlier in cp_finish_decl. */
2272 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 0;
2274 /* Always emit the information for each class every time. */
2275 if (flag_emit_class_debug_always
)
2278 /* If we already know how we're handling this class, handle debug info
2280 if (CLASSTYPE_INTERFACE_KNOWN (t
))
2282 if (CLASSTYPE_INTERFACE_ONLY (t
))
2283 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2284 /* else don't set it. */
2286 /* If the class has a vtable, write out the debug info along with
2288 else if (TYPE_CONTAINS_VPTR_P (t
))
2289 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2291 /* Otherwise, just emit the debug info normally. */
2294 /* Note that we want debugging information for a base class of a class
2295 whose vtable is being emitted. Normally, this would happen because
2296 calling the constructor for a derived class implies calling the
2297 constructors for all bases, which involve initializing the
2298 appropriate vptr with the vtable for the base class; but in the
2299 presence of optimization, this initialization may be optimized
2300 away, so we tell finish_vtable_vardecl that we want the debugging
2301 information anyway. */
2304 dfs_debug_mark (tree binfo
, void * /*data*/)
2306 tree t
= BINFO_TYPE (binfo
);
2308 if (CLASSTYPE_DEBUG_REQUESTED (t
))
2309 return dfs_skip_bases
;
2311 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
2316 /* Write out the debugging information for TYPE, whose vtable is being
2317 emitted. Also walk through our bases and note that we want to
2318 write out information for them. This avoids the problem of not
2319 writing any debug info for intermediate basetypes whose
2320 constructors, and thus the references to their vtables, and thus
2321 the vtables themselves, were optimized away. */
2324 note_debug_info_needed (tree type
)
2326 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
2328 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)) = 0;
2329 rest_of_type_compilation (type
, namespace_bindings_p ());
2332 dfs_walk_all (TYPE_BINFO (type
), dfs_debug_mark
, NULL
, 0);
2335 /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2336 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2337 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2338 bases have been encountered already in the tree walk. PARENT_CONVS
2339 is the list of lists of conversion functions that could hide CONV
2340 and OTHER_CONVS is the list of lists of conversion functions that
2341 could hide or be hidden by CONV, should virtualness be involved in
2342 the hierarchy. Merely checking the conversion op's name is not
2343 enough because two conversion operators to the same type can have
2344 different names. Return nonzero if we are visible. */
2347 check_hidden_convs (tree binfo
, int virtual_depth
, int virtualness
,
2348 tree to_type
, tree parent_convs
, tree other_convs
)
2352 /* See if we are hidden by a parent conversion. */
2353 for (level
= parent_convs
; level
; level
= TREE_CHAIN (level
))
2354 for (probe
= TREE_VALUE (level
); probe
; probe
= TREE_CHAIN (probe
))
2355 if (same_type_p (to_type
, TREE_TYPE (probe
)))
2358 if (virtual_depth
|| virtualness
)
2360 /* In a virtual hierarchy, we could be hidden, or could hide a
2361 conversion function on the other_convs list. */
2362 for (level
= other_convs
; level
; level
= TREE_CHAIN (level
))
2368 if (!(virtual_depth
|| TREE_STATIC (level
)))
2369 /* Neither is morally virtual, so cannot hide each other. */
2372 if (!TREE_VALUE (level
))
2373 /* They evaporated away already. */
2376 they_hide_us
= (virtual_depth
2377 && original_binfo (binfo
, TREE_PURPOSE (level
)));
2378 we_hide_them
= (!they_hide_us
&& TREE_STATIC (level
)
2379 && original_binfo (TREE_PURPOSE (level
), binfo
));
2381 if (!(we_hide_them
|| they_hide_us
))
2382 /* Neither is within the other, so no hiding can occur. */
2385 for (prev
= &TREE_VALUE (level
), other
= *prev
; other
;)
2387 if (same_type_p (to_type
, TREE_TYPE (other
)))
2390 /* We are hidden. */
2395 /* We hide the other one. */
2396 other
= TREE_CHAIN (other
);
2401 prev
= &TREE_CHAIN (other
);
2409 /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2410 of conversion functions, the first slot will be for the current
2411 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2412 of conversion functions from children of the current binfo,
2413 concatenated with conversions from elsewhere in the hierarchy --
2414 that list begins with OTHER_CONVS. Return a single list of lists
2415 containing only conversions from the current binfo and its
2419 split_conversions (tree my_convs
, tree parent_convs
,
2420 tree child_convs
, tree other_convs
)
2425 /* Remove the original other_convs portion from child_convs. */
2426 for (prev
= NULL
, t
= child_convs
;
2427 t
!= other_convs
; prev
= t
, t
= TREE_CHAIN (t
))
2431 TREE_CHAIN (prev
) = NULL_TREE
;
2433 child_convs
= NULL_TREE
;
2435 /* Attach the child convs to any we had at this level. */
2438 my_convs
= parent_convs
;
2439 TREE_CHAIN (my_convs
) = child_convs
;
2442 my_convs
= child_convs
;
2447 /* Worker for lookup_conversions. Lookup conversion functions in
2448 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in a
2449 morally virtual base, and VIRTUALNESS is nonzero, if we've
2450 encountered virtual bases already in the tree walk. PARENT_CONVS
2451 is a list of conversions within parent binfos. OTHER_CONVS are
2452 conversions found elsewhere in the tree. Return the conversions
2453 found within this portion of the graph in CONVS. Return nonzero if
2454 we encountered virtualness. We keep template and non-template
2455 conversions separate, to avoid unnecessary type comparisons.
2457 The located conversion functions are held in lists of lists. The
2458 TREE_VALUE of the outer list is the list of conversion functions
2459 found in a particular binfo. The TREE_PURPOSE of both the outer
2460 and inner lists is the binfo at which those conversions were
2461 found. TREE_STATIC is set for those lists within of morally
2462 virtual binfos. The TREE_VALUE of the inner list is the conversion
2463 function or overload itself. The TREE_TYPE of each inner list node
2464 is the converted-to type. */
2467 lookup_conversions_r (tree binfo
, int virtual_depth
, int virtualness
,
2468 tree parent_convs
, tree other_convs
, tree
*convs
)
2470 int my_virtualness
= 0;
2471 tree my_convs
= NULL_TREE
;
2472 tree child_convs
= NULL_TREE
;
2474 /* If we have no conversion operators, then don't look. */
2475 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo
)))
2482 if (BINFO_VIRTUAL_P (binfo
))
2485 /* First, locate the unhidden ones at this level. */
2486 if (tree conv
= get_class_binding (BINFO_TYPE (binfo
), conv_op_identifier
))
2487 for (ovl_iterator
iter (conv
); iter
; ++iter
)
2490 tree type
= DECL_CONV_FN_TYPE (fn
);
2492 if (TREE_CODE (fn
) != TEMPLATE_DECL
&& type_uses_auto (type
))
2495 type
= DECL_CONV_FN_TYPE (fn
);
2498 if (check_hidden_convs (binfo
, virtual_depth
, virtualness
,
2499 type
, parent_convs
, other_convs
))
2501 my_convs
= tree_cons (binfo
, fn
, my_convs
);
2502 TREE_TYPE (my_convs
) = type
;
2505 TREE_STATIC (my_convs
) = 1;
2513 parent_convs
= tree_cons (binfo
, my_convs
, parent_convs
);
2515 TREE_STATIC (parent_convs
) = 1;
2518 child_convs
= other_convs
;
2520 /* Now iterate over each base, looking for more conversions. */
2523 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2526 unsigned base_virtualness
;
2528 base_virtualness
= lookup_conversions_r (base_binfo
,
2529 virtual_depth
, virtualness
,
2530 parent_convs
, child_convs
,
2532 if (base_virtualness
)
2533 my_virtualness
= virtualness
= 1;
2534 child_convs
= chainon (base_convs
, child_convs
);
2537 *convs
= split_conversions (my_convs
, parent_convs
,
2538 child_convs
, other_convs
);
2540 return my_virtualness
;
2543 /* Return a TREE_LIST containing all the non-hidden user-defined
2544 conversion functions for TYPE (and its base-classes). The
2545 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2546 function. The TREE_PURPOSE is the BINFO from which the conversion
2547 functions in this node were selected. This function is effectively
2548 performing a set of member lookups as lookup_fnfield does, but
2549 using the type being converted to as the unique key, rather than the
2553 lookup_conversions (tree type
)
2557 complete_type (type
);
2558 if (!CLASS_TYPE_P (type
) || !TYPE_BINFO (type
))
2561 lookup_conversions_r (TYPE_BINFO (type
), 0, 0, NULL_TREE
, NULL_TREE
, &convs
);
2563 tree list
= NULL_TREE
;
2565 /* Flatten the list-of-lists */
2566 for (; convs
; convs
= TREE_CHAIN (convs
))
2570 for (probe
= TREE_VALUE (convs
); probe
; probe
= next
)
2572 next
= TREE_CHAIN (probe
);
2574 TREE_CHAIN (probe
) = list
;
2582 /* Returns the binfo of the first direct or indirect virtual base derived
2583 from BINFO, or NULL if binfo is not via virtual. */
2586 binfo_from_vbase (tree binfo
)
2588 for (; binfo
; binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2590 if (BINFO_VIRTUAL_P (binfo
))
2596 /* Returns the binfo of the first direct or indirect virtual base derived
2597 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2601 binfo_via_virtual (tree binfo
, tree limit
)
2603 if (limit
&& !CLASSTYPE_VBASECLASSES (limit
))
2604 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2607 for (; binfo
&& !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), limit
);
2608 binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2610 if (BINFO_VIRTUAL_P (binfo
))
2616 /* BINFO is for a base class in some hierarchy. Return true iff it is a
2620 binfo_direct_p (tree binfo
)
2622 tree d_binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
2623 if (BINFO_INHERITANCE_CHAIN (d_binfo
))
2624 /* A second inheritance chain means indirect. */
2626 if (!BINFO_VIRTUAL_P (binfo
))
2627 /* Non-virtual, so only one inheritance chain means direct. */
2629 /* A virtual base looks like a direct base, so we need to look through the
2630 direct bases to see if it's there. */
2632 for (int i
= 0; BINFO_BASE_ITERATE (d_binfo
, i
, b_binfo
); ++i
)
2633 if (b_binfo
== binfo
)
2638 /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2639 Find the equivalent binfo within whatever graph HERE is located.
2640 This is the inverse of original_binfo. */
2643 copied_binfo (tree binfo
, tree here
)
2645 tree result
= NULL_TREE
;
2647 if (BINFO_VIRTUAL_P (binfo
))
2651 for (t
= here
; BINFO_INHERITANCE_CHAIN (t
);
2652 t
= BINFO_INHERITANCE_CHAIN (t
))
2655 result
= binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (t
));
2657 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2663 cbinfo
= copied_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2664 for (ix
= 0; BINFO_BASE_ITERATE (cbinfo
, ix
, base_binfo
); ix
++)
2665 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
), BINFO_TYPE (binfo
)))
2667 result
= base_binfo
;
2673 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here
), BINFO_TYPE (binfo
)));
2677 gcc_assert (result
);
2682 binfo_for_vbase (tree base
, tree t
)
2686 vec
<tree
, va_gc
> *vbases
;
2688 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
2689 vec_safe_iterate (vbases
, ix
, &binfo
); ix
++)
2690 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), base
))
2695 /* BINFO is some base binfo of HERE, within some other
2696 hierarchy. Return the equivalent binfo, but in the hierarchy
2697 dominated by HERE. This is the inverse of copied_binfo. If BINFO
2698 is not a base binfo of HERE, returns NULL_TREE. */
2701 original_binfo (tree binfo
, tree here
)
2705 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (here
)))
2707 else if (BINFO_VIRTUAL_P (binfo
))
2708 result
= (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here
))
2709 ? binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (here
))
2711 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2715 base_binfos
= original_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2721 for (ix
= 0; (base_binfo
= BINFO_BASE_BINFO (base_binfos
, ix
)); ix
++)
2722 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
2723 BINFO_TYPE (binfo
)))
2725 result
= base_binfo
;
2734 /* True iff TYPE has any dependent bases (and therefore we can't say
2735 definitively that another class is not a base of an instantiation of
2739 any_dependent_bases_p (tree type
)
2741 if (!type
|| !CLASS_TYPE_P (type
) || !uses_template_parms (type
))
2744 /* If we haven't set TYPE_BINFO yet, we don't know anything about the bases.
2745 Return false because in this situation we aren't actually looking up names
2746 in the scope of the class, so it doesn't matter whether it has dependent
2748 if (!TYPE_BINFO (type
))
2753 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_BINFOS (TYPE_BINFO (type
)), i
, base_binfo
)
2754 if (BINFO_DEPENDENT_BASE_P (base_binfo
))