1 /* Breadth-first and depth-first routines for
2 searching multiple-inheritance lattice for GNU C++.
3 Copyright (C) 1987-2016 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.h"
32 static int is_subobject_of_p (tree
, tree
);
33 static tree
dfs_lookup_base (tree
, void *);
34 static tree
dfs_dcast_hint_pre (tree
, void *);
35 static tree
dfs_dcast_hint_post (tree
, void *);
36 static tree
dfs_debug_mark (tree
, void *);
37 static int check_hidden_convs (tree
, int, int, tree
, tree
, tree
);
38 static tree
split_conversions (tree
, tree
, tree
, tree
);
39 static int lookup_conversions_r (tree
, int, int,
40 tree
, tree
, tree
, tree
, tree
*, tree
*);
41 static int look_for_overrides_r (tree
, tree
);
42 static tree
lookup_field_r (tree
, void *);
43 static tree
dfs_accessible_post (tree
, void *);
44 static tree
dfs_walk_once_accessible (tree
, bool,
45 tree (*pre_fn
) (tree
, void *),
46 tree (*post_fn
) (tree
, void *),
48 static tree
dfs_access_in_type (tree
, void *);
49 static access_kind
access_in_type (tree
, tree
);
50 static tree
dfs_get_pure_virtuals (tree
, void *);
53 /* Variables for gathering statistics. */
54 static int n_fields_searched
;
55 static int n_calls_lookup_field
, n_calls_lookup_field_1
;
56 static int n_calls_lookup_fnfields
, n_calls_lookup_fnfields_1
;
57 static int n_calls_get_base_type
;
58 static int n_outer_fields_searched
;
59 static int n_contexts_saved
;
62 /* Data for lookup_base and its workers. */
64 struct lookup_base_data_s
66 tree t
; /* type being searched. */
67 tree base
; /* The base type we're looking for. */
68 tree binfo
; /* Found binfo. */
69 bool via_virtual
; /* Found via a virtual path. */
70 bool ambiguous
; /* Found multiply ambiguous */
71 bool repeated_base
; /* Whether there are repeated bases in the
73 bool want_any
; /* Whether we want any matching binfo. */
76 /* Worker function for lookup_base. See if we've found the desired
77 base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
80 dfs_lookup_base (tree binfo
, void *data_
)
82 struct lookup_base_data_s
*data
= (struct lookup_base_data_s
*) data_
;
84 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->base
))
90 = binfo_via_virtual (data
->binfo
, data
->t
) != NULL_TREE
;
92 if (!data
->repeated_base
)
93 /* If there are no repeated bases, we can stop now. */
96 if (data
->want_any
&& !data
->via_virtual
)
97 /* If this is a non-virtual base, then we can't do
101 return dfs_skip_bases
;
105 gcc_assert (binfo
!= data
->binfo
);
107 /* We've found more than one matching binfo. */
110 /* This is immediately ambiguous. */
111 data
->binfo
= NULL_TREE
;
112 data
->ambiguous
= true;
113 return error_mark_node
;
116 /* Prefer one via a non-virtual path. */
117 if (!binfo_via_virtual (binfo
, data
->t
))
120 data
->via_virtual
= false;
124 /* There must be repeated bases, otherwise we'd have stopped
125 on the first base we found. */
126 return dfs_skip_bases
;
133 /* Returns true if type BASE is accessible in T. (BASE is known to be
134 a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
135 true, consider any special access of the current scope, or access
136 bestowed by friendship. */
139 accessible_base_p (tree t
, tree base
, bool consider_local_p
)
143 /* [class.access.base]
145 A base class is said to be accessible if an invented public
146 member of the base class is accessible.
148 If BASE is a non-proper base, this condition is trivially
150 if (same_type_p (t
, base
))
152 /* Rather than inventing a public member, we use the implicit
153 public typedef created in the scope of every class. */
154 decl
= TYPE_FIELDS (base
);
155 while (!DECL_SELF_REFERENCE_P (decl
))
156 decl
= DECL_CHAIN (decl
);
157 while (ANON_AGGR_TYPE_P (t
))
158 t
= TYPE_CONTEXT (t
);
159 return accessible_p (t
, decl
, consider_local_p
);
162 /* Lookup BASE in the hierarchy dominated by T. Do access checking as
163 ACCESS specifies. Return the binfo we discover. If KIND_PTR is
164 non-NULL, fill with information about what kind of base we
167 If the base is inaccessible, or ambiguous, then error_mark_node is
168 returned. If the tf_error bit of COMPLAIN is not set, no error
172 lookup_base (tree t
, tree base
, base_access access
,
173 base_kind
*kind_ptr
, tsubst_flags_t complain
)
179 /* "Nothing" is definitely not derived from Base. */
183 *kind_ptr
= bk_not_base
;
187 if (t
== error_mark_node
|| base
== error_mark_node
)
190 *kind_ptr
= bk_not_base
;
191 return error_mark_node
;
193 gcc_assert (TYPE_P (base
));
202 t
= complete_type (TYPE_MAIN_VARIANT (t
));
203 t_binfo
= TYPE_BINFO (t
);
206 base
= TYPE_MAIN_VARIANT (base
);
208 /* If BASE is incomplete, it can't be a base of T--and instantiating it
209 might cause an error. */
210 if (t_binfo
&& CLASS_TYPE_P (base
) && COMPLETE_OR_OPEN_TYPE_P (base
))
212 struct lookup_base_data_s data
;
216 data
.binfo
= NULL_TREE
;
217 data
.ambiguous
= data
.via_virtual
= false;
218 data
.repeated_base
= CLASSTYPE_REPEATED_BASE_P (t
);
219 data
.want_any
= access
== ba_any
;
221 dfs_walk_once (t_binfo
, dfs_lookup_base
, NULL
, &data
);
225 bk
= data
.ambiguous
? bk_ambig
: bk_not_base
;
226 else if (binfo
== t_binfo
)
228 else if (data
.via_virtual
)
239 /* Check that the base is unambiguous and accessible. */
240 if (access
!= ba_any
)
247 if (complain
& tf_error
)
248 error ("%qT is an ambiguous base of %qT", base
, t
);
249 binfo
= error_mark_node
;
253 if ((access
& ba_check_bit
)
254 /* If BASE is incomplete, then BASE and TYPE are probably
255 the same, in which case BASE is accessible. If they
256 are not the same, then TYPE is invalid. In that case,
257 there's no need to issue another error here, and
258 there's no implicit typedef to use in the code that
259 follows, so we skip the check. */
260 && COMPLETE_TYPE_P (base
)
261 && !accessible_base_p (t
, base
, !(access
& ba_ignore_scope
)))
263 if (complain
& tf_error
)
264 error ("%qT is an inaccessible base of %qT", base
, t
);
265 binfo
= error_mark_node
;
266 bk
= bk_inaccessible
;
277 /* Data for dcast_base_hint walker. */
281 tree subtype
; /* The base type we're looking for. */
282 int virt_depth
; /* Number of virtual bases encountered from most
284 tree offset
; /* Best hint offset discovered so far. */
285 bool repeated_base
; /* Whether there are repeated bases in the
289 /* Worker for dcast_base_hint. Search for the base type being cast
293 dfs_dcast_hint_pre (tree binfo
, void *data_
)
295 struct dcast_data_s
*data
= (struct dcast_data_s
*) data_
;
297 if (BINFO_VIRTUAL_P (binfo
))
300 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->subtype
))
302 if (data
->virt_depth
)
304 data
->offset
= ssize_int (-1);
308 data
->offset
= ssize_int (-3);
310 data
->offset
= BINFO_OFFSET (binfo
);
312 return data
->repeated_base
? dfs_skip_bases
: data
->offset
;
318 /* Worker for dcast_base_hint. Track the virtual depth. */
321 dfs_dcast_hint_post (tree binfo
, void *data_
)
323 struct dcast_data_s
*data
= (struct dcast_data_s
*) data_
;
325 if (BINFO_VIRTUAL_P (binfo
))
331 /* The dynamic cast runtime needs a hint about how the static SUBTYPE type
332 started from is related to the required TARGET type, in order to optimize
333 the inheritance graph search. This information is independent of the
334 current context, and ignores private paths, hence get_base_distance is
335 inappropriate. Return a TREE specifying the base offset, BOFF.
336 BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
337 and there are no public virtual SUBTYPE bases.
338 BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
339 BOFF == -2, SUBTYPE is not a public base.
340 BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
343 dcast_base_hint (tree subtype
, tree target
)
345 struct dcast_data_s data
;
347 data
.subtype
= subtype
;
349 data
.offset
= NULL_TREE
;
350 data
.repeated_base
= CLASSTYPE_REPEATED_BASE_P (target
);
352 dfs_walk_once_accessible (TYPE_BINFO (target
), /*friends=*/false,
353 dfs_dcast_hint_pre
, dfs_dcast_hint_post
, &data
);
354 return data
.offset
? data
.offset
: ssize_int (-2);
357 /* Search for a member with name NAME in a multiple inheritance
358 lattice specified by TYPE. If it does not exist, return NULL_TREE.
359 If the member is ambiguously referenced, return `error_mark_node'.
360 Otherwise, return a DECL with the indicated name. If WANT_TYPE is
361 true, type declarations are preferred. */
363 /* Do a 1-level search for NAME as a member of TYPE. The caller must
364 figure out whether it can access this field. (Since it is only one
365 level, this is reasonable.) */
368 lookup_field_1 (tree type
, tree name
, bool want_type
)
372 gcc_assert (identifier_p (name
));
374 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
375 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
376 || TREE_CODE (type
) == TYPENAME_TYPE
)
377 /* The TYPE_FIELDS of a TEMPLATE_TYPE_PARM and
378 BOUND_TEMPLATE_TEMPLATE_PARM are not fields at all;
379 instead TYPE_FIELDS is the TEMPLATE_PARM_INDEX. (Miraculously,
380 the code often worked even when we treated the index as a list
382 The TYPE_FIELDS of TYPENAME_TYPE is its TYPENAME_TYPE_FULLNAME. */
385 if (CLASSTYPE_SORTED_FIELDS (type
))
387 tree
*fields
= &CLASSTYPE_SORTED_FIELDS (type
)->elts
[0];
388 int lo
= 0, hi
= CLASSTYPE_SORTED_FIELDS (type
)->len
;
395 if (GATHER_STATISTICS
)
398 if (DECL_NAME (fields
[i
]) > name
)
400 else if (DECL_NAME (fields
[i
]) < name
)
406 /* We might have a nested class and a field with the
407 same name; we sorted them appropriately via
408 field_decl_cmp, so just look for the first or last
409 field with this name. */
414 while (i
>= lo
&& DECL_NAME (fields
[i
]) == name
);
415 if (!DECL_DECLARES_TYPE_P (field
))
422 while (i
< hi
&& DECL_NAME (fields
[i
]) == name
);
427 field
= strip_using_decl (field
);
428 if (is_overloaded_fn (field
))
438 field
= TYPE_FIELDS (type
);
440 if (GATHER_STATISTICS
)
441 n_calls_lookup_field_1
++;
443 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
447 if (GATHER_STATISTICS
)
450 gcc_assert (DECL_P (field
));
451 if (DECL_NAME (field
) == NULL_TREE
452 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
454 tree temp
= lookup_field_1 (TREE_TYPE (field
), name
, want_type
);
459 if (TREE_CODE (decl
) == USING_DECL
460 && DECL_NAME (decl
) == name
)
462 decl
= strip_using_decl (decl
);
463 if (is_overloaded_fn (decl
))
467 if (DECL_NAME (decl
) == name
468 && (!want_type
|| DECL_DECLARES_TYPE_P (decl
)))
472 if (name
== vptr_identifier
)
474 /* Give the user what s/he thinks s/he wants. */
475 if (TYPE_POLYMORPHIC_P (type
))
476 return TYPE_VFIELD (type
);
481 /* Return the FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, or
482 NAMESPACE_DECL corresponding to the innermost non-block scope. */
487 /* There are a number of cases we need to be aware of here:
488 current_class_type current_function_decl
495 Those last two make life interesting. If we're in a function which is
496 itself inside a class, we need decls to go into the fn's decls (our
497 second case below). But if we're in a class and the class itself is
498 inside a function, we need decls to go into the decls for the class. To
499 achieve this last goal, we must see if, when both current_class_ptr and
500 current_function_decl are set, the class was declared inside that
501 function. If so, we know to put the decls into the class's scope. */
502 if (current_function_decl
&& current_class_type
503 && ((DECL_FUNCTION_MEMBER_P (current_function_decl
)
504 && same_type_p (DECL_CONTEXT (current_function_decl
),
506 || (DECL_FRIEND_CONTEXT (current_function_decl
)
507 && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl
),
508 current_class_type
))))
509 return current_function_decl
;
510 if (current_class_type
)
511 return current_class_type
;
512 if (current_function_decl
)
513 return current_function_decl
;
514 return current_namespace
;
517 /* Returns nonzero if we are currently in a function scope. Note
518 that this function returns zero if we are within a local class, but
519 not within a member function body of the local class. */
522 at_function_scope_p (void)
524 tree cs
= current_scope ();
525 /* Also check cfun to make sure that we're really compiling
526 this function (as opposed to having set current_function_decl
527 for access checking or some such). */
528 return (cs
&& TREE_CODE (cs
) == FUNCTION_DECL
529 && cfun
&& cfun
->decl
== current_function_decl
);
532 /* Returns true if the innermost active scope is a class scope. */
535 at_class_scope_p (void)
537 tree cs
= current_scope ();
538 return cs
&& TYPE_P (cs
);
541 /* Returns true if the innermost active scope is a namespace scope. */
544 at_namespace_scope_p (void)
546 tree cs
= current_scope ();
547 return cs
&& TREE_CODE (cs
) == NAMESPACE_DECL
;
550 /* Return the scope of DECL, as appropriate when doing name-lookup. */
553 context_for_name_lookup (tree decl
)
557 For the purposes of name lookup, after the anonymous union
558 definition, the members of the anonymous union are considered to
559 have been defined in the scope in which the anonymous union is
561 tree context
= DECL_CONTEXT (decl
);
563 while (context
&& TYPE_P (context
)
564 && (ANON_AGGR_TYPE_P (context
) || UNSCOPED_ENUM_P (context
)))
565 context
= TYPE_CONTEXT (context
);
567 context
= global_namespace
;
572 /* Returns true iff DECL is declared in TYPE. */
575 member_declared_in_type (tree decl
, tree type
)
577 /* A normal declaration obviously counts. */
578 if (context_for_name_lookup (decl
) == type
)
580 /* So does a using or access declaration. */
581 if (DECL_LANG_SPECIFIC (decl
) && !DECL_DISCRIMINATOR_P (decl
)
582 && purpose_member (type
, DECL_ACCESS (decl
)))
587 /* The accessibility routines use BINFO_ACCESS for scratch space
588 during the computation of the accessibility of some declaration. */
590 /* Avoid walking up past a declaration of the member. */
593 dfs_access_in_type_pre (tree binfo
, void *data
)
595 tree decl
= (tree
) data
;
596 tree type
= BINFO_TYPE (binfo
);
597 if (member_declared_in_type (decl
, type
))
598 return dfs_skip_bases
;
602 #define BINFO_ACCESS(NODE) \
603 ((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE)))
605 /* Set the access associated with NODE to ACCESS. */
607 #define SET_BINFO_ACCESS(NODE, ACCESS) \
608 ((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \
609 (TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0))
611 /* Called from access_in_type via dfs_walk. Calculate the access to
612 DATA (which is really a DECL) in BINFO. */
615 dfs_access_in_type (tree binfo
, void *data
)
617 tree decl
= (tree
) data
;
618 tree type
= BINFO_TYPE (binfo
);
619 access_kind access
= ak_none
;
621 if (context_for_name_lookup (decl
) == type
)
623 /* If we have descended to the scope of DECL, just note the
624 appropriate access. */
625 if (TREE_PRIVATE (decl
))
627 else if (TREE_PROTECTED (decl
))
628 access
= ak_protected
;
634 /* First, check for an access-declaration that gives us more
635 access to the DECL. */
636 if (DECL_LANG_SPECIFIC (decl
) && !DECL_DISCRIMINATOR_P (decl
))
638 tree decl_access
= purpose_member (type
, DECL_ACCESS (decl
));
642 decl_access
= TREE_VALUE (decl_access
);
644 if (decl_access
== access_public_node
)
646 else if (decl_access
== access_protected_node
)
647 access
= ak_protected
;
648 else if (decl_access
== access_private_node
)
659 vec
<tree
, va_gc
> *accesses
;
661 /* Otherwise, scan our baseclasses, and pick the most favorable
663 accesses
= BINFO_BASE_ACCESSES (binfo
);
664 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
666 tree base_access
= (*accesses
)[i
];
667 access_kind base_access_now
= BINFO_ACCESS (base_binfo
);
669 if (base_access_now
== ak_none
|| base_access_now
== ak_private
)
670 /* If it was not accessible in the base, or only
671 accessible as a private member, we can't access it
673 base_access_now
= ak_none
;
674 else if (base_access
== access_protected_node
)
675 /* Public and protected members in the base become
677 base_access_now
= ak_protected
;
678 else if (base_access
== access_private_node
)
679 /* Public and protected members in the base become
681 base_access_now
= ak_private
;
683 /* See if the new access, via this base, gives more
684 access than our previous best access. */
685 if (base_access_now
!= ak_none
686 && (access
== ak_none
|| base_access_now
< access
))
688 access
= base_access_now
;
690 /* If the new access is public, we can't do better. */
691 if (access
== ak_public
)
698 /* Note the access to DECL in TYPE. */
699 SET_BINFO_ACCESS (binfo
, access
);
704 /* Return the access to DECL in TYPE. */
707 access_in_type (tree type
, tree decl
)
709 tree binfo
= TYPE_BINFO (type
);
711 /* We must take into account
715 If a name can be reached by several paths through a multiple
716 inheritance graph, the access is that of the path that gives
719 The algorithm we use is to make a post-order depth-first traversal
720 of the base-class hierarchy. As we come up the tree, we annotate
721 each node with the most lenient access. */
722 dfs_walk_once (binfo
, dfs_access_in_type_pre
, dfs_access_in_type
, decl
);
724 return BINFO_ACCESS (binfo
);
727 /* Returns nonzero if it is OK to access DECL named in TYPE through an object
728 of OTYPE in the context of DERIVED. */
731 protected_accessible_p (tree decl
, tree derived
, tree type
, tree otype
)
733 /* We're checking this clause from [class.access.base]
735 m as a member of N is protected, and the reference occurs in a
736 member or friend of class N, or in a member or friend of a
737 class P derived from N, where m as a member of P is public, private
740 Here DERIVED is a possible P, DECL is m and TYPE is N. */
742 /* If DERIVED isn't derived from N, then it can't be a P. */
743 if (!DERIVED_FROM_P (type
, derived
))
748 When a friend or a member function of a derived class references
749 a protected nonstatic member of a base class, an access check
750 applies in addition to those described earlier in clause
751 _class.access_) Except when forming a pointer to member
752 (_expr.unary.op_), the access must be through a pointer to,
753 reference to, or object of the derived class itself (or any class
754 derived from that class) (_expr.ref_). If the access is to form
755 a pointer to member, the nested-name-specifier shall name the
756 derived class (or any class derived from that class). */
757 if (DECL_NONSTATIC_MEMBER_P (decl
)
758 && !DERIVED_FROM_P (derived
, otype
))
764 /* Returns nonzero if SCOPE is a type or a friend of a type which would be able
765 to access DECL through TYPE. OTYPE is the type of the object. */
768 friend_accessible_p (tree scope
, tree decl
, tree type
, tree otype
)
770 /* We're checking this clause from [class.access.base]
772 m as a member of N is protected, and the reference occurs in a
773 member or friend of class N, or in a member or friend of a
774 class P derived from N, where m as a member of P is public, private
777 Here DECL is m and TYPE is N. SCOPE is the current context,
778 and we check all its possible Ps. */
779 tree befriending_classes
;
785 /* Is SCOPE itself a suitable P? */
786 if (TYPE_P (scope
) && protected_accessible_p (decl
, scope
, type
, otype
))
789 if (DECL_DECLARES_FUNCTION_P (scope
))
790 befriending_classes
= DECL_BEFRIENDING_CLASSES (scope
);
791 else if (TYPE_P (scope
))
792 befriending_classes
= CLASSTYPE_BEFRIENDING_CLASSES (scope
);
796 for (t
= befriending_classes
; t
; t
= TREE_CHAIN (t
))
797 if (protected_accessible_p (decl
, TREE_VALUE (t
), type
, otype
))
800 /* Nested classes have the same access as their enclosing types, as
801 per DR 45 (this is a change from C++98). */
803 if (friend_accessible_p (TYPE_CONTEXT (scope
), decl
, type
, otype
))
806 if (DECL_DECLARES_FUNCTION_P (scope
))
808 /* Perhaps this SCOPE is a member of a class which is a
810 if (DECL_CLASS_SCOPE_P (scope
)
811 && friend_accessible_p (DECL_CONTEXT (scope
), decl
, type
, otype
))
815 /* Maybe scope's template is a friend. */
816 if (tree tinfo
= get_template_info (scope
))
818 tree tmpl
= TI_TEMPLATE (tinfo
);
819 if (DECL_CLASS_TEMPLATE_P (tmpl
))
820 tmpl
= TREE_TYPE (tmpl
);
822 tmpl
= DECL_TEMPLATE_RESULT (tmpl
);
825 /* Increment processing_template_decl to make sure that
826 dependent_type_p works correctly. */
827 ++processing_template_decl
;
828 int ret
= friend_accessible_p (tmpl
, decl
, type
, otype
);
829 --processing_template_decl
;
835 /* If is_friend is true, we should have found a befriending class. */
836 gcc_checking_assert (!is_friend (type
, scope
));
841 struct dfs_accessible_data
847 /* Avoid walking up past a declaration of the member. */
850 dfs_accessible_pre (tree binfo
, void *data
)
852 dfs_accessible_data
*d
= (dfs_accessible_data
*)data
;
853 tree type
= BINFO_TYPE (binfo
);
854 if (member_declared_in_type (d
->decl
, type
))
855 return dfs_skip_bases
;
859 /* Called via dfs_walk_once_accessible from accessible_p */
862 dfs_accessible_post (tree binfo
, void *data
)
864 /* access_in_type already set BINFO_ACCESS for us. */
865 access_kind access
= BINFO_ACCESS (binfo
);
866 tree N
= BINFO_TYPE (binfo
);
867 dfs_accessible_data
*d
= (dfs_accessible_data
*)data
;
869 tree scope
= current_nonlambda_scope ();
871 /* A member m is accessible at the point R when named in class N if */
878 /* m as a member of N is public, or */
883 /* m as a member of N is private, and R occurs in a member or friend of
885 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
886 && is_friend (N
, scope
))
893 /* m as a member of N is protected, and R occurs in a member or friend
894 of class N, or in a member or friend of a class P derived from N,
895 where m as a member of P is public, private, or protected */
896 if (friend_accessible_p (scope
, decl
, N
, d
->object_type
))
906 /* Like accessible_p below, but within a template returns true iff DECL is
907 accessible in TYPE to all possible instantiations of the template. */
910 accessible_in_template_p (tree type
, tree decl
)
912 int save_ptd
= processing_template_decl
;
913 processing_template_decl
= 0;
914 int val
= accessible_p (type
, decl
, false);
915 processing_template_decl
= save_ptd
;
919 /* DECL is a declaration from a base class of TYPE, which was the
920 class used to name DECL. Return nonzero if, in the current
921 context, DECL is accessible. If TYPE is actually a BINFO node,
922 then we can tell in what context the access is occurring by looking
923 at the most derived class along the path indicated by BINFO. If
924 CONSIDER_LOCAL is true, do consider special access the current
925 scope or friendship thereof we might have. */
928 accessible_p (tree type
, tree decl
, bool consider_local_p
)
933 /* If this declaration is in a block or namespace scope, there's no
935 if (!TYPE_P (context_for_name_lookup (decl
)))
938 /* There is no need to perform access checks inside a thunk. */
939 if (current_function_decl
&& DECL_THUNK_P (current_function_decl
))
942 /* In a template declaration, we cannot be sure whether the
943 particular specialization that is instantiated will be a friend
944 or not. Therefore, all access checks are deferred until
945 instantiation. However, PROCESSING_TEMPLATE_DECL is set in the
946 parameter list for a template (because we may see dependent types
947 in default arguments for template parameters), and access
948 checking should be performed in the outermost parameter list. */
949 if (processing_template_decl
950 && (!processing_template_parmlist
|| processing_template_decl
> 1))
953 tree otype
= NULL_TREE
;
956 /* When accessing a non-static member, the most derived type in the
957 binfo chain is the type of the object; remember that type for
958 protected_accessible_p. */
959 for (tree b
= type
; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
960 otype
= BINFO_TYPE (b
);
961 type
= BINFO_TYPE (type
);
966 /* [class.access.base]
968 A member m is accessible when named in class N if
970 --m as a member of N is public, or
972 --m as a member of N is private, and the reference occurs in a
973 member or friend of class N, or
975 --m as a member of N is protected, and the reference occurs in a
976 member or friend of class N, or in a member or friend of a
977 class P derived from N, where m as a member of P is public, private or
980 --there exists a base class B of N that is accessible at the point
981 of reference, and m is accessible when named in class B.
983 We walk the base class hierarchy, checking these conditions. */
985 /* We walk using TYPE_BINFO (type) because access_in_type will set
986 BINFO_ACCESS on it and its bases. */
987 binfo
= TYPE_BINFO (type
);
989 /* Compute the accessibility of DECL in the class hierarchy
990 dominated by type. */
991 access
= access_in_type (type
, decl
);
992 if (access
== ak_public
)
995 /* If we aren't considering the point of reference, only the first bullet
997 if (!consider_local_p
)
1000 dfs_accessible_data d
= { decl
, otype
};
1002 /* Walk the hierarchy again, looking for a base class that allows
1004 return dfs_walk_once_accessible (binfo
, /*friends=*/true,
1006 dfs_accessible_post
, &d
)
1010 struct lookup_field_info
{
1011 /* The type in which we're looking. */
1013 /* The name of the field for which we're looking. */
1015 /* If non-NULL, the current result of the lookup. */
1017 /* The path to RVAL. */
1019 /* If non-NULL, the lookup was ambiguous, and this is a list of the
1022 /* If nonzero, we are looking for types, not data members. */
1024 /* If something went wrong, a message indicating what. */
1028 /* Nonzero for a class member means that it is shared between all objects
1031 [class.member.lookup]:If the resulting set of declarations are not all
1032 from sub-objects of the same type, or the set has a nonstatic member
1033 and includes members from distinct sub-objects, there is an ambiguity
1034 and the program is ill-formed.
1036 This function checks that T contains no nonstatic members. */
1039 shared_member_p (tree t
)
1041 if (VAR_P (t
) || TREE_CODE (t
) == TYPE_DECL \
1042 || TREE_CODE (t
) == CONST_DECL
)
1044 if (is_overloaded_fn (t
))
1047 for (; t
; t
= OVL_NEXT (t
))
1049 tree fn
= OVL_CURRENT (t
);
1050 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
1058 /* Routine to see if the sub-object denoted by the binfo PARENT can be
1059 found as a base class and sub-object of the object denoted by
1063 is_subobject_of_p (tree parent
, tree binfo
)
1067 for (probe
= parent
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
1071 if (BINFO_VIRTUAL_P (probe
))
1072 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (binfo
))
1078 /* DATA is really a struct lookup_field_info. Look for a field with
1079 the name indicated there in BINFO. If this function returns a
1080 non-NULL value it is the result of the lookup. Called from
1081 lookup_field via breadth_first_search. */
1084 lookup_field_r (tree binfo
, void *data
)
1086 struct lookup_field_info
*lfi
= (struct lookup_field_info
*) data
;
1087 tree type
= BINFO_TYPE (binfo
);
1088 tree nval
= NULL_TREE
;
1090 /* If this is a dependent base, don't look in it. */
1091 if (BINFO_DEPENDENT_BASE_P (binfo
))
1094 /* If this base class is hidden by the best-known value so far, we
1095 don't need to look. */
1096 if (lfi
->rval_binfo
&& BINFO_INHERITANCE_CHAIN (binfo
) == lfi
->rval_binfo
1097 && !BINFO_VIRTUAL_P (binfo
))
1098 return dfs_skip_bases
;
1100 /* First, look for a function. There can't be a function and a data
1101 member with the same name, and if there's a function and a type
1102 with the same name, the type is hidden by the function. */
1103 if (!lfi
->want_type
)
1104 nval
= lookup_fnfields_slot (type
, lfi
->name
);
1107 /* Look for a data member or type. */
1108 nval
= lookup_field_1 (type
, lfi
->name
, lfi
->want_type
);
1110 /* If there is no declaration with the indicated name in this type,
1111 then there's nothing to do. */
1115 /* If we're looking up a type (as with an elaborated type specifier)
1116 we ignore all non-types we find. */
1117 if (lfi
->want_type
&& !DECL_DECLARES_TYPE_P (nval
))
1119 if (lfi
->name
== TYPE_IDENTIFIER (type
))
1121 /* If the aggregate has no user defined constructors, we allow
1122 it to have fields with the same name as the enclosing type.
1123 If we are looking for that name, find the corresponding
1125 for (nval
= TREE_CHAIN (nval
); nval
; nval
= TREE_CHAIN (nval
))
1126 if (DECL_NAME (nval
) == lfi
->name
1127 && TREE_CODE (nval
) == TYPE_DECL
)
1132 if (!nval
&& CLASSTYPE_NESTED_UTDS (type
) != NULL
)
1134 binding_entry e
= binding_table_find (CLASSTYPE_NESTED_UTDS (type
),
1137 nval
= TYPE_MAIN_DECL (e
->type
);
1143 /* If the lookup already found a match, and the new value doesn't
1144 hide the old one, we might have an ambiguity. */
1146 && !is_subobject_of_p (lfi
->rval_binfo
, binfo
))
1149 if (nval
== lfi
->rval
&& shared_member_p (nval
))
1150 /* The two things are really the same. */
1152 else if (is_subobject_of_p (binfo
, lfi
->rval_binfo
))
1153 /* The previous value hides the new one. */
1157 /* We have a real ambiguity. We keep a chain of all the
1159 if (!lfi
->ambiguous
&& lfi
->rval
)
1161 /* This is the first time we noticed an ambiguity. Add
1162 what we previously thought was a reasonable candidate
1164 lfi
->ambiguous
= tree_cons (NULL_TREE
, lfi
->rval
, NULL_TREE
);
1165 TREE_TYPE (lfi
->ambiguous
) = error_mark_node
;
1168 /* Add the new value. */
1169 lfi
->ambiguous
= tree_cons (NULL_TREE
, nval
, lfi
->ambiguous
);
1170 TREE_TYPE (lfi
->ambiguous
) = error_mark_node
;
1171 lfi
->errstr
= G_("request for member %qD is ambiguous");
1177 lfi
->rval_binfo
= binfo
;
1181 /* Don't look for constructors or destructors in base classes. */
1182 if (IDENTIFIER_CTOR_OR_DTOR_P (lfi
->name
))
1183 return dfs_skip_bases
;
1187 /* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO,
1188 BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO,
1189 FUNCTIONS, and OPTYPE respectively. */
1192 build_baselink (tree binfo
, tree access_binfo
, tree functions
, tree optype
)
1196 gcc_assert (TREE_CODE (functions
) == FUNCTION_DECL
1197 || TREE_CODE (functions
) == TEMPLATE_DECL
1198 || TREE_CODE (functions
) == TEMPLATE_ID_EXPR
1199 || TREE_CODE (functions
) == OVERLOAD
);
1200 gcc_assert (!optype
|| TYPE_P (optype
));
1201 gcc_assert (TREE_TYPE (functions
));
1203 baselink
= make_node (BASELINK
);
1204 TREE_TYPE (baselink
) = TREE_TYPE (functions
);
1205 BASELINK_BINFO (baselink
) = binfo
;
1206 BASELINK_ACCESS_BINFO (baselink
) = access_binfo
;
1207 BASELINK_FUNCTIONS (baselink
) = functions
;
1208 BASELINK_OPTYPE (baselink
) = optype
;
1213 /* Look for a member named NAME in an inheritance lattice dominated by
1214 XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
1215 is 1, we enforce accessibility. If PROTECT is zero, then, for an
1216 ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
1217 messages about inaccessible or ambiguous lookup. If PROTECT is 2,
1218 we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
1219 TREE_VALUEs are the list of ambiguous candidates.
1221 WANT_TYPE is 1 when we should only return TYPE_DECLs.
1223 If nothing can be found return NULL_TREE and do not issue an error. */
1226 lookup_member (tree xbasetype
, tree name
, int protect
, bool want_type
,
1227 tsubst_flags_t complain
)
1229 tree rval
, rval_binfo
= NULL_TREE
;
1230 tree type
= NULL_TREE
, basetype_path
= NULL_TREE
;
1231 struct lookup_field_info lfi
;
1233 /* rval_binfo is the binfo associated with the found member, note,
1234 this can be set with useful information, even when rval is not
1235 set, because it must deal with ALL members, not just non-function
1236 members. It is used for ambiguity checking and the hidden
1237 checks. Whereas rval is only set if a proper (not hidden)
1238 non-function member is found. */
1240 const char *errstr
= 0;
1242 if (name
== error_mark_node
1243 || xbasetype
== NULL_TREE
1244 || xbasetype
== error_mark_node
)
1247 gcc_assert (identifier_p (name
));
1249 if (TREE_CODE (xbasetype
) == TREE_BINFO
)
1251 type
= BINFO_TYPE (xbasetype
);
1252 basetype_path
= xbasetype
;
1256 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype
)))
1259 xbasetype
= NULL_TREE
;
1262 type
= complete_type (type
);
1264 /* Make sure we're looking for a member of the current instantiation in the
1265 right partial specialization. */
1266 if (flag_concepts
&& dependent_type_p (type
))
1267 if (tree t
= currently_open_class (type
))
1271 basetype_path
= TYPE_BINFO (type
);
1276 if (GATHER_STATISTICS
)
1277 n_calls_lookup_field
++;
1279 memset (&lfi
, 0, sizeof (lfi
));
1282 lfi
.want_type
= want_type
;
1283 dfs_walk_all (basetype_path
, &lookup_field_r
, NULL
, &lfi
);
1285 rval_binfo
= lfi
.rval_binfo
;
1287 type
= BINFO_TYPE (rval_binfo
);
1288 errstr
= lfi
.errstr
;
1290 /* If we are not interested in ambiguities, don't report them;
1291 just return NULL_TREE. */
1292 if (!protect
&& lfi
.ambiguous
)
1298 return lfi
.ambiguous
;
1305 In the case of overloaded function names, access control is
1306 applied to the function selected by overloaded resolution.
1308 We cannot check here, even if RVAL is only a single non-static
1309 member function, since we do not know what the "this" pointer
1312 class A { protected: void f(); };
1313 class B : public A {
1320 only the first call to "f" is valid. However, if the function is
1321 static, we can check. */
1323 && !really_overloaded_fn (rval
))
1325 tree decl
= is_overloaded_fn (rval
) ? get_first_fn (rval
) : rval
;
1326 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
)
1327 && !perform_or_defer_access_check (basetype_path
, decl
, decl
,
1329 rval
= error_mark_node
;
1332 if (errstr
&& protect
)
1334 if (complain
& tf_error
)
1336 error (errstr
, name
, type
);
1338 print_candidates (lfi
.ambiguous
);
1340 rval
= error_mark_node
;
1343 if (rval
&& is_overloaded_fn (rval
))
1344 rval
= build_baselink (rval_binfo
, basetype_path
, rval
,
1345 (IDENTIFIER_TYPENAME_P (name
)
1346 ? TREE_TYPE (name
): NULL_TREE
));
1350 /* Helper class for lookup_member_fuzzy. */
1352 class lookup_field_fuzzy_info
1355 lookup_field_fuzzy_info (bool want_type_p
) :
1356 m_want_type_p (want_type_p
), m_candidates () {}
1358 void fuzzy_lookup_fnfields (tree type
);
1359 void fuzzy_lookup_field (tree type
);
1361 /* If true, we are looking for types, not data members. */
1363 /* The result: a vec of identifiers. */
1364 auto_vec
<tree
> m_candidates
;
1367 /* Locate all methods within TYPE, append them to m_candidates. */
1370 lookup_field_fuzzy_info::fuzzy_lookup_fnfields (tree type
)
1372 vec
<tree
, va_gc
> *method_vec
;
1376 if (!CLASS_TYPE_P (type
))
1379 method_vec
= CLASSTYPE_METHOD_VEC (type
);
1383 for (i
= 0; vec_safe_iterate (method_vec
, i
, &fn
); ++i
)
1385 m_candidates
.safe_push (DECL_NAME (OVL_CURRENT (fn
)));
1388 /* Locate all fields within TYPE, append them to m_candidates. */
1391 lookup_field_fuzzy_info::fuzzy_lookup_field (tree type
)
1393 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
1394 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
1395 || TREE_CODE (type
) == TYPENAME_TYPE
)
1396 /* The TYPE_FIELDS of a TEMPLATE_TYPE_PARM and
1397 BOUND_TEMPLATE_TEMPLATE_PARM are not fields at all;
1398 instead TYPE_FIELDS is the TEMPLATE_PARM_INDEX.
1399 The TYPE_FIELDS of TYPENAME_TYPE is its TYPENAME_TYPE_FULLNAME. */
1402 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1404 if (!m_want_type_p
|| DECL_DECLARES_TYPE_P (field
))
1405 if (DECL_NAME (field
))
1406 m_candidates
.safe_push (DECL_NAME (field
));
1411 /* Helper function for lookup_member_fuzzy, called via dfs_walk_all
1412 DATA is really a lookup_field_fuzzy_info. Look for a field with
1413 the name indicated there in BINFO. Gathers pertinent identifiers into
1417 lookup_field_fuzzy_r (tree binfo
, void *data
)
1419 lookup_field_fuzzy_info
*lffi
= (lookup_field_fuzzy_info
*) data
;
1420 tree type
= BINFO_TYPE (binfo
);
1422 /* First, look for functions. */
1423 if (!lffi
->m_want_type_p
)
1424 lffi
->fuzzy_lookup_fnfields (type
);
1426 /* Look for data member and types. */
1427 lffi
->fuzzy_lookup_field (type
);
1432 /* Like lookup_member, but try to find the closest match for NAME,
1433 rather than an exact match, and return an identifier (or NULL_TREE).
1437 lookup_member_fuzzy (tree xbasetype
, tree name
, bool want_type_p
)
1439 tree type
= NULL_TREE
, basetype_path
= NULL_TREE
;
1440 struct lookup_field_fuzzy_info
lffi (want_type_p
);
1442 /* rval_binfo is the binfo associated with the found member, note,
1443 this can be set with useful information, even when rval is not
1444 set, because it must deal with ALL members, not just non-function
1445 members. It is used for ambiguity checking and the hidden
1446 checks. Whereas rval is only set if a proper (not hidden)
1447 non-function member is found. */
1449 if (name
== error_mark_node
1450 || xbasetype
== NULL_TREE
1451 || xbasetype
== error_mark_node
)
1454 gcc_assert (identifier_p (name
));
1456 if (TREE_CODE (xbasetype
) == TREE_BINFO
)
1458 type
= BINFO_TYPE (xbasetype
);
1459 basetype_path
= xbasetype
;
1463 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype
)))
1466 xbasetype
= NULL_TREE
;
1469 type
= complete_type (type
);
1471 /* Make sure we're looking for a member of the current instantiation in the
1472 right partial specialization. */
1473 if (flag_concepts
&& dependent_type_p (type
))
1474 type
= currently_open_class (type
);
1477 basetype_path
= TYPE_BINFO (type
);
1482 /* Populate lffi.m_candidates. */
1483 dfs_walk_all (basetype_path
, &lookup_field_fuzzy_r
, NULL
, &lffi
);
1485 return find_closest_identifier (name
, &lffi
.m_candidates
);
1488 /* Like lookup_member, except that if we find a function member we
1489 return NULL_TREE. */
1492 lookup_field (tree xbasetype
, tree name
, int protect
, bool want_type
)
1494 tree rval
= lookup_member (xbasetype
, name
, protect
, want_type
,
1495 tf_warning_or_error
);
1497 /* Ignore functions, but propagate the ambiguity list. */
1498 if (!error_operand_p (rval
)
1499 && (rval
&& BASELINK_P (rval
)))
1505 /* Like lookup_member, except that if we find a non-function member we
1506 return NULL_TREE. */
1509 lookup_fnfields (tree xbasetype
, tree name
, int protect
)
1511 tree rval
= lookup_member (xbasetype
, name
, protect
, /*want_type=*/false,
1512 tf_warning_or_error
);
1514 /* Ignore non-functions, but propagate the ambiguity list. */
1515 if (!error_operand_p (rval
)
1516 && (rval
&& !BASELINK_P (rval
)))
1522 /* Return the index in the CLASSTYPE_METHOD_VEC for CLASS_TYPE
1523 corresponding to "operator TYPE ()", or -1 if there is no such
1524 operator. Only CLASS_TYPE itself is searched; this routine does
1525 not scan the base classes of CLASS_TYPE. */
1528 lookup_conversion_operator (tree class_type
, tree type
)
1532 if (TYPE_HAS_CONVERSION (class_type
))
1536 vec
<tree
, va_gc
> *methods
= CLASSTYPE_METHOD_VEC (class_type
);
1538 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1539 vec_safe_iterate (methods
, i
, &fn
); ++i
)
1541 /* All the conversion operators come near the beginning of
1542 the class. Therefore, if FN is not a conversion
1543 operator, there is no matching conversion operator in
1545 fn
= OVL_CURRENT (fn
);
1546 if (!DECL_CONV_FN_P (fn
))
1549 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1550 /* All the templated conversion functions are on the same
1551 slot, so remember it. */
1553 else if (same_type_p (DECL_CONV_FN_TYPE (fn
), type
))
1561 /* TYPE is a class type. Return the index of the fields within
1562 the method vector with name NAME, or -1 if no such field exists.
1563 Does not lazily declare implicitly-declared member functions. */
1566 lookup_fnfields_idx_nolazy (tree type
, tree name
)
1568 vec
<tree
, va_gc
> *method_vec
;
1573 if (!CLASS_TYPE_P (type
))
1576 method_vec
= CLASSTYPE_METHOD_VEC (type
);
1580 if (GATHER_STATISTICS
)
1581 n_calls_lookup_fnfields_1
++;
1583 /* Constructors are first... */
1584 if (name
== ctor_identifier
)
1586 fn
= CLASSTYPE_CONSTRUCTORS (type
);
1587 return fn
? CLASSTYPE_CONSTRUCTOR_SLOT
: -1;
1589 /* and destructors are second. */
1590 if (name
== dtor_identifier
)
1592 fn
= CLASSTYPE_DESTRUCTORS (type
);
1593 return fn
? CLASSTYPE_DESTRUCTOR_SLOT
: -1;
1595 if (IDENTIFIER_TYPENAME_P (name
))
1596 return lookup_conversion_operator (type
, TREE_TYPE (name
));
1598 /* Skip the conversion operators. */
1599 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1600 vec_safe_iterate (method_vec
, i
, &fn
);
1602 if (!DECL_CONV_FN_P (OVL_CURRENT (fn
)))
1605 /* If the type is complete, use binary search. */
1606 if (COMPLETE_TYPE_P (type
))
1612 hi
= method_vec
->length ();
1617 if (GATHER_STATISTICS
)
1618 n_outer_fields_searched
++;
1620 tmp
= (*method_vec
)[i
];
1621 tmp
= DECL_NAME (OVL_CURRENT (tmp
));
1624 else if (tmp
< name
)
1631 for (; vec_safe_iterate (method_vec
, i
, &fn
); ++i
)
1633 if (GATHER_STATISTICS
)
1634 n_outer_fields_searched
++;
1635 if (DECL_NAME (OVL_CURRENT (fn
)) == name
)
1642 /* TYPE is a class type. Return the index of the fields within
1643 the method vector with name NAME, or -1 if no such field exists. */
1646 lookup_fnfields_1 (tree type
, tree name
)
1648 if (!CLASS_TYPE_P (type
))
1651 if (COMPLETE_TYPE_P (type
))
1653 if ((name
== ctor_identifier
1654 || name
== base_ctor_identifier
1655 || name
== complete_ctor_identifier
))
1657 if (CLASSTYPE_LAZY_DEFAULT_CTOR (type
))
1658 lazily_declare_fn (sfk_constructor
, type
);
1659 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
1660 lazily_declare_fn (sfk_copy_constructor
, type
);
1661 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
1662 lazily_declare_fn (sfk_move_constructor
, type
);
1664 else if (name
== ansi_assopname (NOP_EXPR
))
1666 if (CLASSTYPE_LAZY_COPY_ASSIGN (type
))
1667 lazily_declare_fn (sfk_copy_assignment
, type
);
1668 if (CLASSTYPE_LAZY_MOVE_ASSIGN (type
))
1669 lazily_declare_fn (sfk_move_assignment
, type
);
1671 else if ((name
== dtor_identifier
1672 || name
== base_dtor_identifier
1673 || name
== complete_dtor_identifier
1674 || name
== deleting_dtor_identifier
)
1675 && CLASSTYPE_LAZY_DESTRUCTOR (type
))
1676 lazily_declare_fn (sfk_destructor
, type
);
1679 return lookup_fnfields_idx_nolazy (type
, name
);
1682 /* TYPE is a class type. Return the field within the method vector with
1683 name NAME, or NULL_TREE if no such field exists. */
1686 lookup_fnfields_slot (tree type
, tree name
)
1688 int ix
= lookup_fnfields_1 (complete_type (type
), name
);
1691 return (*CLASSTYPE_METHOD_VEC (type
))[ix
];
1694 /* As above, but avoid lazily declaring functions. */
1697 lookup_fnfields_slot_nolazy (tree type
, tree name
)
1699 int ix
= lookup_fnfields_idx_nolazy (complete_type (type
), name
);
1702 return (*CLASSTYPE_METHOD_VEC (type
))[ix
];
1705 /* Like lookup_fnfields_1, except that the name is extracted from
1706 FUNCTION, which is a FUNCTION_DECL or a TEMPLATE_DECL. */
1709 class_method_index_for_fn (tree class_type
, tree function
)
1711 gcc_assert (DECL_DECLARES_FUNCTION_P (function
));
1713 return lookup_fnfields_1 (class_type
,
1714 DECL_CONSTRUCTOR_P (function
) ? ctor_identifier
:
1715 DECL_DESTRUCTOR_P (function
) ? dtor_identifier
:
1716 DECL_NAME (function
));
1720 /* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
1721 the class or namespace used to qualify the name. CONTEXT_CLASS is
1722 the class corresponding to the object in which DECL will be used.
1723 Return a possibly modified version of DECL that takes into account
1726 In particular, consider an expression like `B::m' in the context of
1727 a derived class `D'. If `B::m' has been resolved to a BASELINK,
1728 then the most derived class indicated by the BASELINK_BINFO will be
1729 `B', not `D'. This function makes that adjustment. */
1732 adjust_result_of_qualified_name_lookup (tree decl
,
1733 tree qualifying_scope
,
1736 if (context_class
&& context_class
!= error_mark_node
1737 && CLASS_TYPE_P (context_class
)
1738 && CLASS_TYPE_P (qualifying_scope
)
1739 && DERIVED_FROM_P (qualifying_scope
, context_class
)
1740 && BASELINK_P (decl
))
1744 /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
1745 Because we do not yet know which function will be chosen by
1746 overload resolution, we cannot yet check either accessibility
1747 or ambiguity -- in either case, the choice of a static member
1748 function might make the usage valid. */
1749 base
= lookup_base (context_class
, qualifying_scope
,
1750 ba_unique
, NULL
, tf_none
);
1751 if (base
&& base
!= error_mark_node
)
1753 BASELINK_ACCESS_BINFO (decl
) = base
;
1755 = lookup_base (base
, BINFO_TYPE (BASELINK_BINFO (decl
)),
1756 ba_unique
, NULL
, tf_none
);
1757 if (decl_binfo
&& decl_binfo
!= error_mark_node
)
1758 BASELINK_BINFO (decl
) = decl_binfo
;
1762 if (BASELINK_P (decl
))
1763 BASELINK_QUALIFIED_P (decl
) = true;
1769 /* Walk the class hierarchy within BINFO, in a depth-first traversal.
1770 PRE_FN is called in preorder, while POST_FN is called in postorder.
1771 If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
1772 walked. If PRE_FN or POST_FN returns a different non-NULL value,
1773 that value is immediately returned and the walk is terminated. One
1774 of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
1775 POST_FN are passed the binfo to examine and the caller's DATA
1776 value. All paths are walked, thus virtual and morally virtual
1777 binfos can be multiply walked. */
1780 dfs_walk_all (tree binfo
, tree (*pre_fn
) (tree
, void *),
1781 tree (*post_fn
) (tree
, void *), void *data
)
1787 /* Call the pre-order walking function. */
1790 rval
= pre_fn (binfo
, data
);
1793 if (rval
== dfs_skip_bases
)
1799 /* Find the next child binfo to walk. */
1800 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1802 rval
= dfs_walk_all (base_binfo
, pre_fn
, post_fn
, data
);
1808 /* Call the post-order walking function. */
1811 rval
= post_fn (binfo
, data
);
1812 gcc_assert (rval
!= dfs_skip_bases
);
1819 /* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1820 that binfos are walked at most once. */
1823 dfs_walk_once_r (tree binfo
, tree (*pre_fn
) (tree
, void *),
1824 tree (*post_fn
) (tree
, void *), hash_set
<tree
> *pset
,
1831 /* Call the pre-order walking function. */
1834 rval
= pre_fn (binfo
, data
);
1837 if (rval
== dfs_skip_bases
)
1844 /* Find the next child binfo to walk. */
1845 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1847 if (BINFO_VIRTUAL_P (base_binfo
))
1848 if (pset
->add (base_binfo
))
1851 rval
= dfs_walk_once_r (base_binfo
, pre_fn
, post_fn
, pset
, data
);
1857 /* Call the post-order walking function. */
1860 rval
= post_fn (binfo
, data
);
1861 gcc_assert (rval
!= dfs_skip_bases
);
1868 /* Like dfs_walk_all, except that binfos are not multiply walked. For
1869 non-diamond shaped hierarchies this is the same as dfs_walk_all.
1870 For diamond shaped hierarchies we must mark the virtual bases, to
1871 avoid multiple walks. */
1874 dfs_walk_once (tree binfo
, tree (*pre_fn
) (tree
, void *),
1875 tree (*post_fn
) (tree
, void *), void *data
)
1877 static int active
= 0; /* We must not be called recursively. */
1880 gcc_assert (pre_fn
|| post_fn
);
1881 gcc_assert (!active
);
1884 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
)))
1885 /* We are not diamond shaped, and therefore cannot encounter the
1886 same binfo twice. */
1887 rval
= dfs_walk_all (binfo
, pre_fn
, post_fn
, data
);
1890 hash_set
<tree
> pset
;
1891 rval
= dfs_walk_once_r (binfo
, pre_fn
, post_fn
, &pset
, data
);
1899 /* Worker function for dfs_walk_once_accessible. Behaves like
1900 dfs_walk_once_r, except (a) FRIENDS_P is true if special
1901 access given by the current context should be considered, (b) ONCE
1902 indicates whether bases should be marked during traversal. */
1905 dfs_walk_once_accessible_r (tree binfo
, bool friends_p
, hash_set
<tree
> *pset
,
1906 tree (*pre_fn
) (tree
, void *),
1907 tree (*post_fn
) (tree
, void *), void *data
)
1909 tree rval
= NULL_TREE
;
1913 /* Call the pre-order walking function. */
1916 rval
= pre_fn (binfo
, data
);
1919 if (rval
== dfs_skip_bases
)
1926 /* Find the next child binfo to walk. */
1927 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1929 bool mark
= pset
&& BINFO_VIRTUAL_P (base_binfo
);
1931 if (mark
&& pset
->contains (base_binfo
))
1934 /* If the base is inherited via private or protected
1935 inheritance, then we can't see it, unless we are a friend of
1936 the current binfo. */
1937 if (BINFO_BASE_ACCESS (binfo
, ix
) != access_public_node
)
1942 scope
= current_scope ();
1944 || TREE_CODE (scope
) == NAMESPACE_DECL
1945 || !is_friend (BINFO_TYPE (binfo
), scope
))
1950 pset
->add (base_binfo
);
1952 rval
= dfs_walk_once_accessible_r (base_binfo
, friends_p
, pset
,
1953 pre_fn
, post_fn
, data
);
1959 /* Call the post-order walking function. */
1962 rval
= post_fn (binfo
, data
);
1963 gcc_assert (rval
!= dfs_skip_bases
);
1970 /* Like dfs_walk_once except that only accessible bases are walked.
1971 FRIENDS_P indicates whether friendship of the local context
1972 should be considered when determining accessibility. */
1975 dfs_walk_once_accessible (tree binfo
, bool friends_p
,
1976 tree (*pre_fn
) (tree
, void *),
1977 tree (*post_fn
) (tree
, void *), void *data
)
1979 hash_set
<tree
> *pset
= NULL
;
1980 if (CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo
)))
1981 pset
= new hash_set
<tree
>;
1982 tree rval
= dfs_walk_once_accessible_r (binfo
, friends_p
, pset
,
1983 pre_fn
, post_fn
, data
);
1990 /* Check that virtual overrider OVERRIDER is acceptable for base function
1991 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
1994 check_final_overrider (tree overrider
, tree basefn
)
1996 tree over_type
= TREE_TYPE (overrider
);
1997 tree base_type
= TREE_TYPE (basefn
);
1998 tree over_return
= fndecl_declared_return_type (overrider
);
1999 tree base_return
= fndecl_declared_return_type (basefn
);
2000 tree over_throw
, base_throw
;
2004 if (DECL_INVALID_OVERRIDER_P (overrider
))
2007 if (same_type_p (base_return
, over_return
))
2009 else if ((CLASS_TYPE_P (over_return
) && CLASS_TYPE_P (base_return
))
2010 || (TREE_CODE (base_return
) == TREE_CODE (over_return
)
2011 && POINTER_TYPE_P (base_return
)))
2013 /* Potentially covariant. */
2014 unsigned base_quals
, over_quals
;
2016 fail
= !POINTER_TYPE_P (base_return
);
2019 fail
= cp_type_quals (base_return
) != cp_type_quals (over_return
);
2021 base_return
= TREE_TYPE (base_return
);
2022 over_return
= TREE_TYPE (over_return
);
2024 base_quals
= cp_type_quals (base_return
);
2025 over_quals
= cp_type_quals (over_return
);
2027 if ((base_quals
& over_quals
) != over_quals
)
2030 if (CLASS_TYPE_P (base_return
) && CLASS_TYPE_P (over_return
))
2032 /* Strictly speaking, the standard requires the return type to be
2033 complete even if it only differs in cv-quals, but that seems
2034 like a bug in the wording. */
2035 if (!same_type_ignoring_top_level_qualifiers_p (base_return
,
2038 tree binfo
= lookup_base (over_return
, base_return
,
2039 ba_check
, NULL
, tf_none
);
2041 if (!binfo
|| binfo
== error_mark_node
)
2045 else if (can_convert_standard (TREE_TYPE (base_type
),
2046 TREE_TYPE (over_type
),
2047 tf_warning_or_error
))
2048 /* GNU extension, allow trivial pointer conversions such as
2049 converting to void *, or qualification conversion. */
2051 if (pedwarn (DECL_SOURCE_LOCATION (overrider
), 0,
2052 "invalid covariant return type for %q#D", overrider
))
2053 inform (DECL_SOURCE_LOCATION (basefn
),
2054 " overriding %q#D", basefn
);
2067 error ("invalid covariant return type for %q+#D", overrider
);
2068 error (" overriding %q+#D", basefn
);
2072 error ("conflicting return type specified for %q+#D", overrider
);
2073 error (" overriding %q+#D", basefn
);
2075 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2079 /* Check throw specifier is at least as strict. */
2080 maybe_instantiate_noexcept (basefn
);
2081 maybe_instantiate_noexcept (overrider
);
2082 base_throw
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (basefn
));
2083 over_throw
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (overrider
));
2085 if (!comp_except_specs (base_throw
, over_throw
, ce_derived
))
2087 error ("looser throw specifier for %q+#F", overrider
);
2088 error (" overriding %q+#F", basefn
);
2089 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2093 /* Check for conflicting type attributes. But leave transaction_safe for
2094 set_one_vmethod_tm_attributes. */
2095 if (!comp_type_attributes (over_type
, base_type
)
2096 && !tx_safe_fn_type_p (base_type
)
2097 && !tx_safe_fn_type_p (over_type
))
2099 error ("conflicting type attributes specified for %q+#D", overrider
);
2100 error (" overriding %q+#D", basefn
);
2101 DECL_INVALID_OVERRIDER_P (overrider
) = 1;
2105 /* A function declared transaction_safe_dynamic that overrides a function
2106 declared transaction_safe (but not transaction_safe_dynamic) is
2108 if (tx_safe_fn_type_p (base_type
)
2109 && lookup_attribute ("transaction_safe_dynamic",
2110 DECL_ATTRIBUTES (overrider
))
2111 && !lookup_attribute ("transaction_safe_dynamic",
2112 DECL_ATTRIBUTES (basefn
)))
2114 error_at (DECL_SOURCE_LOCATION (overrider
),
2115 "%qD declared %<transaction_safe_dynamic%>", overrider
);
2116 inform (DECL_SOURCE_LOCATION (basefn
),
2117 "overriding %qD declared %<transaction_safe%>", basefn
);
2120 if (DECL_DELETED_FN (basefn
) != DECL_DELETED_FN (overrider
))
2122 if (DECL_DELETED_FN (overrider
))
2124 error ("deleted function %q+D", overrider
);
2125 error ("overriding non-deleted function %q+D", basefn
);
2126 maybe_explain_implicit_delete (overrider
);
2130 error ("non-deleted function %q+D", overrider
);
2131 error ("overriding deleted function %q+D", basefn
);
2135 if (DECL_FINAL_P (basefn
))
2137 error ("virtual function %q+D", overrider
);
2138 error ("overriding final function %q+D", basefn
);
2144 /* Given a class TYPE, and a function decl FNDECL, look for
2145 virtual functions in TYPE's hierarchy which FNDECL overrides.
2146 We do not look in TYPE itself, only its bases.
2148 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
2149 find that it overrides anything.
2151 We check that every function which is overridden, is correctly
2155 look_for_overrides (tree type
, tree fndecl
)
2157 tree binfo
= TYPE_BINFO (type
);
2162 /* A constructor for a class T does not override a function T
2164 if (DECL_CONSTRUCTOR_P (fndecl
))
2167 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2169 tree basetype
= BINFO_TYPE (base_binfo
);
2171 if (TYPE_POLYMORPHIC_P (basetype
))
2172 found
+= look_for_overrides_r (basetype
, fndecl
);
2177 /* Look in TYPE for virtual functions with the same signature as
2181 look_for_overrides_here (tree type
, tree fndecl
)
2185 /* If there are no methods in TYPE (meaning that only implicitly
2186 declared methods will ever be provided for TYPE), then there are
2187 no virtual functions. */
2188 if (!CLASSTYPE_METHOD_VEC (type
))
2191 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fndecl
))
2192 ix
= CLASSTYPE_DESTRUCTOR_SLOT
;
2194 ix
= lookup_fnfields_1 (type
, DECL_NAME (fndecl
));
2197 tree fns
= (*CLASSTYPE_METHOD_VEC (type
))[ix
];
2199 for (; fns
; fns
= OVL_NEXT (fns
))
2201 tree fn
= OVL_CURRENT (fns
);
2203 if (!DECL_VIRTUAL_P (fn
))
2204 /* Not a virtual. */;
2205 else if (DECL_CONTEXT (fn
) != type
)
2206 /* Introduced with a using declaration. */;
2207 else if (DECL_STATIC_FUNCTION_P (fndecl
))
2209 tree btypes
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2210 tree dtypes
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2211 if (compparms (TREE_CHAIN (btypes
), dtypes
))
2214 else if (same_signature_p (fndecl
, fn
))
2221 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
2222 TYPE itself and its bases. */
2225 look_for_overrides_r (tree type
, tree fndecl
)
2227 tree fn
= look_for_overrides_here (type
, fndecl
);
2230 if (DECL_STATIC_FUNCTION_P (fndecl
))
2232 /* A static member function cannot match an inherited
2233 virtual member function. */
2234 error ("%q+#D cannot be declared", fndecl
);
2235 error (" since %q+#D declared in base class", fn
);
2239 /* It's definitely virtual, even if not explicitly set. */
2240 DECL_VIRTUAL_P (fndecl
) = 1;
2241 check_final_overrider (fndecl
, fn
);
2246 /* We failed to find one declared in this class. Look in its bases. */
2247 return look_for_overrides (type
, fndecl
);
2250 /* Called via dfs_walk from dfs_get_pure_virtuals. */
2253 dfs_get_pure_virtuals (tree binfo
, void *data
)
2255 tree type
= (tree
) data
;
2257 /* We're not interested in primary base classes; the derived class
2258 of which they are a primary base will contain the information we
2260 if (!BINFO_PRIMARY_P (binfo
))
2264 for (virtuals
= BINFO_VIRTUALS (binfo
);
2266 virtuals
= TREE_CHAIN (virtuals
))
2267 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals
)))
2268 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (type
), BV_FN (virtuals
));
2274 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
2277 get_pure_virtuals (tree type
)
2279 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
2280 is going to be overridden. */
2281 CLASSTYPE_PURE_VIRTUALS (type
) = NULL
;
2282 /* Now, run through all the bases which are not primary bases, and
2283 collect the pure virtual functions. We look at the vtable in
2284 each class to determine what pure virtual functions are present.
2285 (A primary base is not interesting because the derived class of
2286 which it is a primary base will contain vtable entries for the
2287 pure virtuals in the base class. */
2288 dfs_walk_once (TYPE_BINFO (type
), NULL
, dfs_get_pure_virtuals
, type
);
2291 /* Debug info for C++ classes can get very large; try to avoid
2292 emitting it everywhere.
2294 Note that this optimization wins even when the target supports
2295 BINCL (if only slightly), and reduces the amount of work for the
2299 maybe_suppress_debug_info (tree t
)
2301 if (write_symbols
== NO_DEBUG
)
2304 /* We might have set this earlier in cp_finish_decl. */
2305 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 0;
2307 /* Always emit the information for each class every time. */
2308 if (flag_emit_class_debug_always
)
2311 /* If we already know how we're handling this class, handle debug info
2313 if (CLASSTYPE_INTERFACE_KNOWN (t
))
2315 if (CLASSTYPE_INTERFACE_ONLY (t
))
2316 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2317 /* else don't set it. */
2319 /* If the class has a vtable, write out the debug info along with
2321 else if (TYPE_CONTAINS_VPTR_P (t
))
2322 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t
)) = 1;
2324 /* Otherwise, just emit the debug info normally. */
2327 /* Note that we want debugging information for a base class of a class
2328 whose vtable is being emitted. Normally, this would happen because
2329 calling the constructor for a derived class implies calling the
2330 constructors for all bases, which involve initializing the
2331 appropriate vptr with the vtable for the base class; but in the
2332 presence of optimization, this initialization may be optimized
2333 away, so we tell finish_vtable_vardecl that we want the debugging
2334 information anyway. */
2337 dfs_debug_mark (tree binfo
, void * /*data*/)
2339 tree t
= BINFO_TYPE (binfo
);
2341 if (CLASSTYPE_DEBUG_REQUESTED (t
))
2342 return dfs_skip_bases
;
2344 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
2349 /* Write out the debugging information for TYPE, whose vtable is being
2350 emitted. Also walk through our bases and note that we want to
2351 write out information for them. This avoids the problem of not
2352 writing any debug info for intermediate basetypes whose
2353 constructors, and thus the references to their vtables, and thus
2354 the vtables themselves, were optimized away. */
2357 note_debug_info_needed (tree type
)
2359 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
2361 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)) = 0;
2362 rest_of_type_compilation (type
, toplevel_bindings_p ());
2365 dfs_walk_all (TYPE_BINFO (type
), dfs_debug_mark
, NULL
, 0);
2369 print_search_statistics (void)
2371 if (! GATHER_STATISTICS
)
2373 fprintf (stderr
, "no search statistics\n");
2377 fprintf (stderr
, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
2378 n_fields_searched
, n_calls_lookup_field
, n_calls_lookup_field_1
);
2379 fprintf (stderr
, "%d fnfields searched in %d calls to lookup_fnfields\n",
2380 n_outer_fields_searched
, n_calls_lookup_fnfields
);
2381 fprintf (stderr
, "%d calls to get_base_type\n", n_calls_get_base_type
);
2385 reinit_search_statistics (void)
2387 n_fields_searched
= 0;
2388 n_calls_lookup_field
= 0, n_calls_lookup_field_1
= 0;
2389 n_calls_lookup_fnfields
= 0, n_calls_lookup_fnfields_1
= 0;
2390 n_calls_get_base_type
= 0;
2391 n_outer_fields_searched
= 0;
2392 n_contexts_saved
= 0;
2395 /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2396 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2397 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2398 bases have been encountered already in the tree walk. PARENT_CONVS
2399 is the list of lists of conversion functions that could hide CONV
2400 and OTHER_CONVS is the list of lists of conversion functions that
2401 could hide or be hidden by CONV, should virtualness be involved in
2402 the hierarchy. Merely checking the conversion op's name is not
2403 enough because two conversion operators to the same type can have
2404 different names. Return nonzero if we are visible. */
2407 check_hidden_convs (tree binfo
, int virtual_depth
, int virtualness
,
2408 tree to_type
, tree parent_convs
, tree other_convs
)
2412 /* See if we are hidden by a parent conversion. */
2413 for (level
= parent_convs
; level
; level
= TREE_CHAIN (level
))
2414 for (probe
= TREE_VALUE (level
); probe
; probe
= TREE_CHAIN (probe
))
2415 if (same_type_p (to_type
, TREE_TYPE (probe
)))
2418 if (virtual_depth
|| virtualness
)
2420 /* In a virtual hierarchy, we could be hidden, or could hide a
2421 conversion function on the other_convs list. */
2422 for (level
= other_convs
; level
; level
= TREE_CHAIN (level
))
2428 if (!(virtual_depth
|| TREE_STATIC (level
)))
2429 /* Neither is morally virtual, so cannot hide each other. */
2432 if (!TREE_VALUE (level
))
2433 /* They evaporated away already. */
2436 they_hide_us
= (virtual_depth
2437 && original_binfo (binfo
, TREE_PURPOSE (level
)));
2438 we_hide_them
= (!they_hide_us
&& TREE_STATIC (level
)
2439 && original_binfo (TREE_PURPOSE (level
), binfo
));
2441 if (!(we_hide_them
|| they_hide_us
))
2442 /* Neither is within the other, so no hiding can occur. */
2445 for (prev
= &TREE_VALUE (level
), other
= *prev
; other
;)
2447 if (same_type_p (to_type
, TREE_TYPE (other
)))
2450 /* We are hidden. */
2455 /* We hide the other one. */
2456 other
= TREE_CHAIN (other
);
2461 prev
= &TREE_CHAIN (other
);
2469 /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2470 of conversion functions, the first slot will be for the current
2471 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2472 of conversion functions from children of the current binfo,
2473 concatenated with conversions from elsewhere in the hierarchy --
2474 that list begins with OTHER_CONVS. Return a single list of lists
2475 containing only conversions from the current binfo and its
2479 split_conversions (tree my_convs
, tree parent_convs
,
2480 tree child_convs
, tree other_convs
)
2485 /* Remove the original other_convs portion from child_convs. */
2486 for (prev
= NULL
, t
= child_convs
;
2487 t
!= other_convs
; prev
= t
, t
= TREE_CHAIN (t
))
2491 TREE_CHAIN (prev
) = NULL_TREE
;
2493 child_convs
= NULL_TREE
;
2495 /* Attach the child convs to any we had at this level. */
2498 my_convs
= parent_convs
;
2499 TREE_CHAIN (my_convs
) = child_convs
;
2502 my_convs
= child_convs
;
2507 /* Worker for lookup_conversions. Lookup conversion functions in
2508 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in
2509 a morally virtual base, and VIRTUALNESS is nonzero, if we've
2510 encountered virtual bases already in the tree walk. PARENT_CONVS &
2511 PARENT_TPL_CONVS are lists of list of conversions within parent
2512 binfos. OTHER_CONVS and OTHER_TPL_CONVS are conversions found
2513 elsewhere in the tree. Return the conversions found within this
2514 portion of the graph in CONVS and TPL_CONVS. Return nonzero is we
2515 encountered virtualness. We keep template and non-template
2516 conversions separate, to avoid unnecessary type comparisons.
2518 The located conversion functions are held in lists of lists. The
2519 TREE_VALUE of the outer list is the list of conversion functions
2520 found in a particular binfo. The TREE_PURPOSE of both the outer
2521 and inner lists is the binfo at which those conversions were
2522 found. TREE_STATIC is set for those lists within of morally
2523 virtual binfos. The TREE_VALUE of the inner list is the conversion
2524 function or overload itself. The TREE_TYPE of each inner list node
2525 is the converted-to type. */
2528 lookup_conversions_r (tree binfo
,
2529 int virtual_depth
, int virtualness
,
2530 tree parent_convs
, tree parent_tpl_convs
,
2531 tree other_convs
, tree other_tpl_convs
,
2532 tree
*convs
, tree
*tpl_convs
)
2534 int my_virtualness
= 0;
2535 tree my_convs
= NULL_TREE
;
2536 tree my_tpl_convs
= NULL_TREE
;
2537 tree child_convs
= NULL_TREE
;
2538 tree child_tpl_convs
= NULL_TREE
;
2541 vec
<tree
, va_gc
> *method_vec
= CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo
));
2544 /* If we have no conversion operators, then don't look. */
2545 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo
)))
2547 *convs
= *tpl_convs
= NULL_TREE
;
2552 if (BINFO_VIRTUAL_P (binfo
))
2555 /* First, locate the unhidden ones at this level. */
2556 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2557 vec_safe_iterate (method_vec
, i
, &conv
);
2560 tree cur
= OVL_CURRENT (conv
);
2562 if (!DECL_CONV_FN_P (cur
))
2565 if (TREE_CODE (cur
) == TEMPLATE_DECL
)
2567 /* Only template conversions can be overloaded, and we must
2568 flatten them out and check each one individually. */
2571 for (tpls
= conv
; tpls
; tpls
= OVL_NEXT (tpls
))
2573 tree tpl
= OVL_CURRENT (tpls
);
2574 tree type
= DECL_CONV_FN_TYPE (tpl
);
2576 if (check_hidden_convs (binfo
, virtual_depth
, virtualness
,
2577 type
, parent_tpl_convs
, other_tpl_convs
))
2579 my_tpl_convs
= tree_cons (binfo
, tpl
, my_tpl_convs
);
2580 TREE_TYPE (my_tpl_convs
) = type
;
2583 TREE_STATIC (my_tpl_convs
) = 1;
2591 tree name
= DECL_NAME (cur
);
2593 if (!IDENTIFIER_MARKED (name
))
2595 tree type
= DECL_CONV_FN_TYPE (cur
);
2596 if (type_uses_auto (type
))
2599 type
= DECL_CONV_FN_TYPE (cur
);
2602 if (check_hidden_convs (binfo
, virtual_depth
, virtualness
,
2603 type
, parent_convs
, other_convs
))
2605 my_convs
= tree_cons (binfo
, conv
, my_convs
);
2606 TREE_TYPE (my_convs
) = type
;
2609 TREE_STATIC (my_convs
) = 1;
2612 IDENTIFIER_MARKED (name
) = 1;
2620 parent_convs
= tree_cons (binfo
, my_convs
, parent_convs
);
2622 TREE_STATIC (parent_convs
) = 1;
2627 parent_tpl_convs
= tree_cons (binfo
, my_tpl_convs
, parent_tpl_convs
);
2629 TREE_STATIC (parent_tpl_convs
) = 1;
2632 child_convs
= other_convs
;
2633 child_tpl_convs
= other_tpl_convs
;
2635 /* Now iterate over each base, looking for more conversions. */
2636 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2638 tree base_convs
, base_tpl_convs
;
2639 unsigned base_virtualness
;
2641 base_virtualness
= lookup_conversions_r (base_binfo
,
2642 virtual_depth
, virtualness
,
2643 parent_convs
, parent_tpl_convs
,
2644 child_convs
, child_tpl_convs
,
2645 &base_convs
, &base_tpl_convs
);
2646 if (base_virtualness
)
2647 my_virtualness
= virtualness
= 1;
2648 child_convs
= chainon (base_convs
, child_convs
);
2649 child_tpl_convs
= chainon (base_tpl_convs
, child_tpl_convs
);
2652 /* Unmark the conversions found at this level */
2653 for (conv
= my_convs
; conv
; conv
= TREE_CHAIN (conv
))
2654 IDENTIFIER_MARKED (DECL_NAME (OVL_CURRENT (TREE_VALUE (conv
)))) = 0;
2656 *convs
= split_conversions (my_convs
, parent_convs
,
2657 child_convs
, other_convs
);
2658 *tpl_convs
= split_conversions (my_tpl_convs
, parent_tpl_convs
,
2659 child_tpl_convs
, other_tpl_convs
);
2661 return my_virtualness
;
2664 /* Return a TREE_LIST containing all the non-hidden user-defined
2665 conversion functions for TYPE (and its base-classes). The
2666 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2667 function. The TREE_PURPOSE is the BINFO from which the conversion
2668 functions in this node were selected. This function is effectively
2669 performing a set of member lookups as lookup_fnfield does, but
2670 using the type being converted to as the unique key, rather than the
2674 lookup_conversions (tree type
)
2676 tree convs
, tpl_convs
;
2677 tree list
= NULL_TREE
;
2679 complete_type (type
);
2680 if (!CLASS_TYPE_P (type
) || !TYPE_BINFO (type
))
2683 lookup_conversions_r (TYPE_BINFO (type
), 0, 0,
2684 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
,
2685 &convs
, &tpl_convs
);
2687 /* Flatten the list-of-lists */
2688 for (; convs
; convs
= TREE_CHAIN (convs
))
2692 for (probe
= TREE_VALUE (convs
); probe
; probe
= next
)
2694 next
= TREE_CHAIN (probe
);
2696 TREE_CHAIN (probe
) = list
;
2701 for (; tpl_convs
; tpl_convs
= TREE_CHAIN (tpl_convs
))
2705 for (probe
= TREE_VALUE (tpl_convs
); probe
; probe
= next
)
2707 next
= TREE_CHAIN (probe
);
2709 TREE_CHAIN (probe
) = list
;
2717 /* Returns the binfo of the first direct or indirect virtual base derived
2718 from BINFO, or NULL if binfo is not via virtual. */
2721 binfo_from_vbase (tree binfo
)
2723 for (; binfo
; binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2725 if (BINFO_VIRTUAL_P (binfo
))
2731 /* Returns the binfo of the first direct or indirect virtual base derived
2732 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2736 binfo_via_virtual (tree binfo
, tree limit
)
2738 if (limit
&& !CLASSTYPE_VBASECLASSES (limit
))
2739 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2742 for (; binfo
&& !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), limit
);
2743 binfo
= BINFO_INHERITANCE_CHAIN (binfo
))
2745 if (BINFO_VIRTUAL_P (binfo
))
2751 /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2752 Find the equivalent binfo within whatever graph HERE is located.
2753 This is the inverse of original_binfo. */
2756 copied_binfo (tree binfo
, tree here
)
2758 tree result
= NULL_TREE
;
2760 if (BINFO_VIRTUAL_P (binfo
))
2764 for (t
= here
; BINFO_INHERITANCE_CHAIN (t
);
2765 t
= BINFO_INHERITANCE_CHAIN (t
))
2768 result
= binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (t
));
2770 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2776 cbinfo
= copied_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2777 for (ix
= 0; BINFO_BASE_ITERATE (cbinfo
, ix
, base_binfo
); ix
++)
2778 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
), BINFO_TYPE (binfo
)))
2780 result
= base_binfo
;
2786 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here
), BINFO_TYPE (binfo
)));
2790 gcc_assert (result
);
2795 binfo_for_vbase (tree base
, tree t
)
2799 vec
<tree
, va_gc
> *vbases
;
2801 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
2802 vec_safe_iterate (vbases
, ix
, &binfo
); ix
++)
2803 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), base
))
2808 /* BINFO is some base binfo of HERE, within some other
2809 hierarchy. Return the equivalent binfo, but in the hierarchy
2810 dominated by HERE. This is the inverse of copied_binfo. If BINFO
2811 is not a base binfo of HERE, returns NULL_TREE. */
2814 original_binfo (tree binfo
, tree here
)
2818 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (here
)))
2820 else if (BINFO_VIRTUAL_P (binfo
))
2821 result
= (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here
))
2822 ? binfo_for_vbase (BINFO_TYPE (binfo
), BINFO_TYPE (here
))
2824 else if (BINFO_INHERITANCE_CHAIN (binfo
))
2828 base_binfos
= original_binfo (BINFO_INHERITANCE_CHAIN (binfo
), here
);
2834 for (ix
= 0; (base_binfo
= BINFO_BASE_BINFO (base_binfos
, ix
)); ix
++)
2835 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
2836 BINFO_TYPE (binfo
)))
2838 result
= base_binfo
;