Branch data Line data Source code
1 : : /* Breadth-first and depth-first routines for
2 : : searching multiple-inheritance lattice for GNU C++.
3 : : Copyright (C) 1987-2024 Free Software Foundation, Inc.
4 : : Contributed by Michael Tiemann (tiemann@cygnus.com)
5 : :
6 : : This file is part of GCC.
7 : :
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)
11 : : any later version.
12 : :
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.
17 : :
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/>. */
21 : :
22 : : /* High-level class interface. */
23 : :
24 : : #include "config.h"
25 : : #include "system.h"
26 : : #include "coretypes.h"
27 : : #include "cp-tree.h"
28 : : #include "intl.h"
29 : : #include "toplev.h"
30 : : #include "spellcheck-tree.h"
31 : : #include "stringpool.h"
32 : : #include "attribs.h"
33 : : #include "tree-inline.h"
34 : :
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 *),
49 : : void *data);
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 *);
53 : :
54 : :
55 : : /* Data for lookup_base and its workers. */
56 : :
57 : : struct lookup_base_data_s
58 : : {
59 : : HOST_WIDE_INT offset; /* Offset we want, or -1 if any. */
60 : : tree t; /* type being searched. */
61 : : tree base; /* The base type we're looking for. */
62 : : tree binfo; /* Found binfo. */
63 : : bool via_virtual; /* Found via a virtual path. */
64 : : bool ambiguous; /* Found multiply ambiguous */
65 : : bool repeated_base; /* Whether there are repeated bases in the
66 : : hierarchy. */
67 : : bool want_any; /* Whether we want any matching binfo. */
68 : : };
69 : :
70 : : /* Worker function for lookup_base. See if we've found the desired
71 : : base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
72 : :
73 : : static tree
74 : 749453578 : dfs_lookup_base (tree binfo, void *data_)
75 : : {
76 : 749453578 : struct lookup_base_data_s *data = (struct lookup_base_data_s *) data_;
77 : :
78 : 749453578 : if (data->offset != -1)
79 : : {
80 : : /* We're looking for the type at a particular offset. */
81 : 5260317 : int comp = compare_tree_int (BINFO_OFFSET (binfo), data->offset);
82 : 5260317 : if (comp > 0)
83 : : /* Don't bother looking into bases laid out later; even if they
84 : : do virtually inherit from the base we want, we can get there
85 : : by another path. */
86 : : return dfs_skip_bases;
87 : 5259470 : else if (comp != 0
88 : 5260359 : && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->base))
89 : : /* Right type, wrong offset. */
90 : : return dfs_skip_bases;
91 : : /* Fall through. */
92 : : }
93 : :
94 : 749452728 : if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->base))
95 : : {
96 : 346261570 : if (!data->binfo)
97 : : {
98 : 346260194 : data->binfo = binfo;
99 : 346260194 : data->via_virtual
100 : 346260194 : = binfo_via_virtual (data->binfo, data->t) != NULL_TREE;
101 : :
102 : 346260194 : if (!data->repeated_base)
103 : : /* If there are no repeated bases, we can stop now. */
104 : : return binfo;
105 : :
106 : 13030 : if (data->want_any && !data->via_virtual)
107 : : /* If this is a non-virtual base, then we can't do
108 : : better. */
109 : : return binfo;
110 : :
111 : : return dfs_skip_bases;
112 : : }
113 : : else
114 : : {
115 : 1376 : gcc_assert (binfo != data->binfo);
116 : :
117 : : /* We've found more than one matching binfo. */
118 : 1376 : if (!data->want_any)
119 : : {
120 : : /* This is immediately ambiguous. */
121 : 1241 : data->binfo = NULL_TREE;
122 : 1241 : data->ambiguous = true;
123 : 1241 : return error_mark_node;
124 : : }
125 : :
126 : : /* Prefer one via a non-virtual path. */
127 : 135 : if (!binfo_via_virtual (binfo, data->t))
128 : : {
129 : 36 : data->binfo = binfo;
130 : 36 : data->via_virtual = false;
131 : 36 : return binfo;
132 : : }
133 : :
134 : : /* There must be repeated bases, otherwise we'd have stopped
135 : : on the first base we found. */
136 : : return dfs_skip_bases;
137 : : }
138 : : }
139 : :
140 : : return NULL_TREE;
141 : : }
142 : :
143 : : /* This deals with bug PR17314.
144 : :
145 : : DECL is a declaration and BINFO represents a class that has attempted (but
146 : : failed) to access DECL.
147 : :
148 : : Examine the parent binfos of BINFO and determine whether any of them had
149 : : private access to DECL. If they did, return the parent binfo. This helps
150 : : in figuring out the correct error message to show (if the parents had
151 : : access, it's their fault for not giving sufficient access to BINFO).
152 : :
153 : : If no parents had access, return NULL_TREE. */
154 : :
155 : : tree
156 : 1331 : get_parent_with_private_access (tree decl, tree binfo)
157 : : {
158 : : /* Only BINFOs should come through here. */
159 : 1331 : gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
160 : :
161 : 1452 : tree base_binfo = NULL_TREE;
162 : :
163 : : /* Iterate through immediate parent classes. */
164 : 1452 : for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
165 : : {
166 : : /* This parent had private access. Therefore that's why BINFO can't
167 : : access DECL. */
168 : 342 : if (access_in_type (BINFO_TYPE (base_binfo), decl) == ak_private)
169 : 221 : return base_binfo;
170 : : }
171 : :
172 : : /* None of the parents had access. Note: it's impossible for one of the
173 : : parents to have had public or protected access to DECL, since then
174 : : BINFO would have been able to access DECL too. */
175 : : return NULL_TREE;
176 : : }
177 : :
178 : : /* Returns true if type BASE is accessible in T. (BASE is known to be
179 : : a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
180 : : true, consider any special access of the current scope, or access
181 : : bestowed by friendship. */
182 : :
183 : : bool
184 : 34331097 : accessible_base_p (tree t, tree base, bool consider_local_p)
185 : : {
186 : 34331097 : tree decl;
187 : :
188 : : /* [class.access.base]
189 : :
190 : : A base class is said to be accessible if an invented public
191 : : member of the base class is accessible.
192 : :
193 : : If BASE is a non-proper base, this condition is trivially
194 : : true. */
195 : 34331097 : if (same_type_p (t, base))
196 : : return true;
197 : : /* Rather than inventing a public member, we use the implicit
198 : : public typedef created in the scope of every class. */
199 : 7935859 : decl = TYPE_FIELDS (base);
200 : 538696904 : while (!DECL_SELF_REFERENCE_P (decl))
201 : 530761045 : decl = DECL_CHAIN (decl);
202 : 7935859 : while (ANON_AGGR_TYPE_P (t))
203 : 0 : t = TYPE_CONTEXT (t);
204 : 7935859 : return accessible_p (t, decl, consider_local_p);
205 : : }
206 : :
207 : : /* Lookup BASE in the hierarchy dominated by T. Do access checking as
208 : : ACCESS specifies. Return the binfo we discover. If KIND_PTR is
209 : : non-NULL, fill with information about what kind of base we
210 : : discovered. If OFFSET is other than -1, only match at that offset.
211 : :
212 : : If the base is inaccessible, or ambiguous, then error_mark_node is
213 : : returned. If the tf_error bit of COMPLAIN is not set, no error
214 : : is issued. */
215 : :
216 : : tree
217 : 579826037 : lookup_base (tree t, tree base, base_access access,
218 : : base_kind *kind_ptr, tsubst_flags_t complain,
219 : : HOST_WIDE_INT offset /* = -1 */)
220 : : {
221 : 579826037 : tree binfo;
222 : 579826037 : tree t_binfo;
223 : 579826037 : base_kind bk;
224 : :
225 : : /* "Nothing" is definitely not derived from Base. */
226 : 579826037 : if (t == NULL_TREE)
227 : : {
228 : 4674 : if (kind_ptr)
229 : 0 : *kind_ptr = bk_not_base;
230 : 4674 : return NULL_TREE;
231 : : }
232 : :
233 : 579821363 : if (t == error_mark_node || base == error_mark_node)
234 : : {
235 : 0 : if (kind_ptr)
236 : 0 : *kind_ptr = bk_not_base;
237 : 0 : return error_mark_node;
238 : : }
239 : 579821363 : gcc_assert (TYPE_P (base));
240 : :
241 : 579821363 : if (!TYPE_P (t))
242 : : {
243 : 2836654 : t_binfo = t;
244 : 2836654 : t = BINFO_TYPE (t);
245 : : }
246 : : else
247 : : {
248 : 576984709 : t = complete_type (TYPE_MAIN_VARIANT (t));
249 : 576984709 : if (dependent_type_p (t))
250 : 140409293 : if (tree open = currently_open_class (t))
251 : 576984709 : t = open;
252 : 576984709 : t_binfo = TYPE_BINFO (t);
253 : : }
254 : :
255 : 579821363 : base = TYPE_MAIN_VARIANT (base);
256 : :
257 : : /* If BASE is incomplete, it can't be a base of T--and instantiating it
258 : : might cause an error. */
259 : 579821363 : if (t_binfo && CLASS_TYPE_P (base) && COMPLETE_OR_OPEN_TYPE_P (base))
260 : : {
261 : 575207009 : struct lookup_base_data_s data;
262 : :
263 : 575207009 : data.t = t;
264 : 575207009 : data.base = base;
265 : 575207009 : data.binfo = NULL_TREE;
266 : 575207009 : data.ambiguous = data.via_virtual = false;
267 : 575207009 : data.repeated_base = (offset == -1) && CLASSTYPE_REPEATED_BASE_P (t);
268 : 575207009 : data.want_any = access == ba_any;
269 : 575207009 : data.offset = offset;
270 : :
271 : 575207009 : dfs_walk_once (t_binfo, dfs_lookup_base, NULL, &data);
272 : 575207009 : binfo = data.binfo;
273 : :
274 : 575207009 : if (!binfo)
275 : 228948056 : bk = data.ambiguous ? bk_ambig : bk_not_base;
276 : 346258953 : else if (binfo == t_binfo)
277 : : bk = bk_same_type;
278 : 65349575 : else if (data.via_virtual)
279 : : bk = bk_via_virtual;
280 : : else
281 : 64754833 : bk = bk_proper_base;
282 : : }
283 : : else
284 : : {
285 : : binfo = NULL_TREE;
286 : : bk = bk_not_base;
287 : : }
288 : :
289 : : /* Check that the base is unambiguous and accessible. */
290 : 579821363 : if (access != ba_any)
291 : 13031239 : switch (bk)
292 : : {
293 : : case bk_not_base:
294 : : break;
295 : :
296 : 1241 : case bk_ambig:
297 : 1241 : if (complain & tf_error)
298 : 106 : error ("%qT is an ambiguous base of %qT", base, t);
299 : 1241 : binfo = error_mark_node;
300 : 1241 : break;
301 : :
302 : 13018899 : default:
303 : 13018899 : if ((access & ba_check_bit)
304 : : /* If BASE is incomplete, then BASE and TYPE are probably
305 : : the same, in which case BASE is accessible. If they
306 : : are not the same, then TYPE is invalid. In that case,
307 : : there's no need to issue another error here, and
308 : : there's no implicit typedef to use in the code that
309 : : follows, so we skip the check. */
310 : 3367735 : && COMPLETE_TYPE_P (base)
311 : 16386628 : && !accessible_base_p (t, base, !(access & ba_ignore_scope)))
312 : : {
313 : 292 : if (complain & tf_error)
314 : 60 : error ("%qT is an inaccessible base of %qT", base, t);
315 : 292 : binfo = error_mark_node;
316 : 292 : bk = bk_inaccessible;
317 : : }
318 : : break;
319 : : }
320 : :
321 : 579821363 : if (kind_ptr)
322 : 3200220 : *kind_ptr = bk;
323 : :
324 : : return binfo;
325 : : }
326 : :
327 : : /* Data for dcast_base_hint walker. */
328 : :
329 : : struct dcast_data_s
330 : : {
331 : : tree subtype; /* The base type we're looking for. */
332 : : int virt_depth; /* Number of virtual bases encountered from most
333 : : derived. */
334 : : tree offset; /* Best hint offset discovered so far. */
335 : : bool repeated_base; /* Whether there are repeated bases in the
336 : : hierarchy. */
337 : : };
338 : :
339 : : /* Worker for dcast_base_hint. Search for the base type being cast
340 : : from. */
341 : :
342 : : static tree
343 : 14741 : dfs_dcast_hint_pre (tree binfo, void *data_)
344 : : {
345 : 14741 : struct dcast_data_s *data = (struct dcast_data_s *) data_;
346 : :
347 : 14741 : if (BINFO_VIRTUAL_P (binfo))
348 : 180 : data->virt_depth++;
349 : :
350 : 14741 : if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->subtype))
351 : : {
352 : 6871 : if (data->virt_depth)
353 : : {
354 : 160 : data->offset = ssize_int (-1);
355 : 160 : return data->offset;
356 : : }
357 : 6711 : if (data->offset)
358 : 4 : data->offset = ssize_int (-3);
359 : : else
360 : 6707 : data->offset = BINFO_OFFSET (binfo);
361 : :
362 : 6711 : return data->repeated_base ? dfs_skip_bases : data->offset;
363 : : }
364 : :
365 : : return NULL_TREE;
366 : : }
367 : :
368 : : /* Worker for dcast_base_hint. Track the virtual depth. */
369 : :
370 : : static tree
371 : 685 : dfs_dcast_hint_post (tree binfo, void *data_)
372 : : {
373 : 685 : struct dcast_data_s *data = (struct dcast_data_s *) data_;
374 : :
375 : 685 : if (BINFO_VIRTUAL_P (binfo))
376 : 4 : data->virt_depth--;
377 : :
378 : 685 : return NULL_TREE;
379 : : }
380 : :
381 : : /* The dynamic cast runtime needs a hint about how the static SUBTYPE type
382 : : started from is related to the required TARGET type, in order to optimize
383 : : the inheritance graph search. This information is independent of the
384 : : current context, and ignores private paths, hence get_base_distance is
385 : : inappropriate. Return a TREE specifying the base offset, BOFF.
386 : : BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
387 : : and there are no public virtual SUBTYPE bases.
388 : : BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
389 : : BOFF == -2, SUBTYPE is not a public base.
390 : : BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
391 : :
392 : : tree
393 : 7068 : dcast_base_hint (tree subtype, tree target)
394 : : {
395 : 7068 : struct dcast_data_s data;
396 : :
397 : 7068 : data.subtype = subtype;
398 : 7068 : data.virt_depth = 0;
399 : 7068 : data.offset = NULL_TREE;
400 : 7068 : data.repeated_base = CLASSTYPE_REPEATED_BASE_P (target);
401 : :
402 : 7068 : dfs_walk_once_accessible (TYPE_BINFO (target), /*friends=*/false,
403 : : dfs_dcast_hint_pre, dfs_dcast_hint_post, &data);
404 : 7068 : return data.offset ? data.offset : ssize_int (-2);
405 : : }
406 : :
407 : : /* Search for a member with name NAME in a multiple inheritance
408 : : lattice specified by TYPE. If it does not exist, return NULL_TREE.
409 : : If the member is ambiguously referenced, return `error_mark_node'.
410 : : Otherwise, return a DECL with the indicated name. If WANT_TYPE is
411 : : true, type declarations are preferred. */
412 : :
413 : : /* Return the FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, or
414 : : NAMESPACE_DECL corresponding to the innermost non-block scope. */
415 : :
416 : : tree
417 : 1688008851 : current_scope (void)
418 : : {
419 : : /* There are a number of cases we need to be aware of here:
420 : : current_class_type current_function_decl
421 : : global NULL NULL
422 : : fn-local NULL SET
423 : : class-local SET NULL
424 : : class->fn SET SET
425 : : fn->class SET SET
426 : :
427 : : Those last two make life interesting. If we're in a function which is
428 : : itself inside a class, we need decls to go into the fn's decls (our
429 : : second case below). But if we're in a class and the class itself is
430 : : inside a function, we need decls to go into the decls for the class. To
431 : : achieve this last goal, we must see if, when both current_class_ptr and
432 : : current_function_decl are set, the class was declared inside that
433 : : function. If so, we know to put the decls into the class's scope. */
434 : 405953234 : if (current_function_decl && current_class_type
435 : 1951805049 : && ((DECL_FUNCTION_MEMBER_P (current_function_decl)
436 : 258862975 : && same_type_p (DECL_CONTEXT (current_function_decl),
437 : : current_class_type))
438 : 19492363 : || (DECL_FRIEND_CONTEXT (current_function_decl)
439 : 3156363 : && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl),
440 : : current_class_type))))
441 : 257041570 : return current_function_decl;
442 : :
443 : 1430967281 : if (current_class_type)
444 : : return current_class_type;
445 : :
446 : 701442640 : if (current_function_decl)
447 : : return current_function_decl;
448 : :
449 : 559285604 : return current_namespace;
450 : : }
451 : :
452 : : /* Returns nonzero if we are currently in a function scope. Note
453 : : that this function returns zero if we are within a local class, but
454 : : not within a member function body of the local class. */
455 : :
456 : : int
457 : 394327357 : at_function_scope_p (void)
458 : : {
459 : 394327357 : tree cs = current_scope ();
460 : : /* Also check cfun to make sure that we're really compiling
461 : : this function (as opposed to having set current_function_decl
462 : : for access checking or some such). */
463 : 394327357 : return (cs && TREE_CODE (cs) == FUNCTION_DECL
464 : 526170863 : && cfun && cfun->decl == current_function_decl);
465 : : }
466 : :
467 : : /* Returns true if the innermost active scope is a class scope. */
468 : :
469 : : bool
470 : 573321612 : at_class_scope_p (void)
471 : : {
472 : 573321612 : tree cs = current_scope ();
473 : 573321612 : return cs && TYPE_P (cs);
474 : : }
475 : :
476 : : /* Returns true if the innermost active scope is a namespace scope. */
477 : :
478 : : bool
479 : 282276640 : at_namespace_scope_p (void)
480 : : {
481 : 282276640 : tree cs = current_scope ();
482 : 282276640 : return cs && TREE_CODE (cs) == NAMESPACE_DECL;
483 : : }
484 : :
485 : : /* Return the scope of DECL, as appropriate when doing name-lookup. */
486 : :
487 : : tree
488 : 4698447685 : context_for_name_lookup (tree decl)
489 : : {
490 : : /* [class.union]
491 : :
492 : : For the purposes of name lookup, after the anonymous union
493 : : definition, the members of the anonymous union are considered to
494 : : have been defined in the scope in which the anonymous union is
495 : : declared. */
496 : 4698447685 : tree context = DECL_CONTEXT (decl);
497 : :
498 : 8995006089 : while (context && TYPE_P (context)
499 : 6667106622 : && (ANON_AGGR_TYPE_P (context) || UNSCOPED_ENUM_P (context)))
500 : 51686095 : context = TYPE_CONTEXT (context);
501 : 4698447685 : if (!context)
502 : 453575376 : context = global_namespace;
503 : :
504 : 4698447685 : return context;
505 : : }
506 : :
507 : : /* Like the above, but always return a type, because it's simpler for member
508 : : handling to refer to the anonymous aggr rather than a function. */
509 : :
510 : : tree
511 : 928167 : type_context_for_name_lookup (tree decl)
512 : : {
513 : 928167 : tree context = DECL_P (decl) ? DECL_CONTEXT (decl) : decl;
514 : 928167 : gcc_checking_assert (CLASS_TYPE_P (context));
515 : :
516 : 930254 : while (context && TYPE_P (context) && ANON_AGGR_TYPE_P (context))
517 : : {
518 : 2099 : tree next = TYPE_CONTEXT (context);
519 : 2099 : if (!TYPE_P (next))
520 : : break;
521 : : context = next;
522 : : }
523 : 928167 : return context;
524 : : }
525 : :
526 : : /* Returns true iff DECL is declared in TYPE. */
527 : :
528 : : static bool
529 : 366396277 : member_declared_in_type (tree decl, tree type)
530 : : {
531 : : /* A normal declaration obviously counts. */
532 : 366396277 : if (context_for_name_lookup (decl) == type)
533 : : return true;
534 : : /* So does a using or access declaration. */
535 : 112641310 : if (DECL_LANG_SPECIFIC (decl) && !DECL_DISCRIMINATOR_P (decl)
536 : 112641310 : && purpose_member (type, DECL_ACCESS (decl)))
537 : : return true;
538 : : return false;
539 : : }
540 : :
541 : : /* The accessibility routines use BINFO_ACCESS for scratch space
542 : : during the computation of the accessibility of some declaration. */
543 : :
544 : : /* Avoid walking up past a declaration of the member. */
545 : :
546 : : static tree
547 : 325067791 : dfs_access_in_type_pre (tree binfo, void *data)
548 : : {
549 : 325067791 : tree decl = (tree) data;
550 : 325067791 : tree type = BINFO_TYPE (binfo);
551 : 325067791 : if (member_declared_in_type (decl, type))
552 : 270270176 : return dfs_skip_bases;
553 : : return NULL_TREE;
554 : : }
555 : :
556 : : #define BINFO_ACCESS(NODE) \
557 : : ((access_kind) ((TREE_PUBLIC (NODE) << 1) | TREE_PRIVATE (NODE)))
558 : :
559 : : /* Set the access associated with NODE to ACCESS. */
560 : :
561 : : #define SET_BINFO_ACCESS(NODE, ACCESS) \
562 : : ((TREE_PUBLIC (NODE) = ((ACCESS) & 2) != 0), \
563 : : (TREE_PRIVATE (NODE) = ((ACCESS) & 1) != 0))
564 : :
565 : : /* Called from access_in_type via dfs_walk. Calculate the access to
566 : : DATA (which is really a DECL) in BINFO. */
567 : :
568 : : static tree
569 : 325067791 : dfs_access_in_type (tree binfo, void *data)
570 : : {
571 : 325067791 : tree decl = (tree) data;
572 : 325067791 : tree type = BINFO_TYPE (binfo);
573 : 325067791 : access_kind access = ak_none;
574 : :
575 : 325067791 : if (context_for_name_lookup (decl) == type)
576 : : {
577 : : /* If we have descended to the scope of DECL, just note the
578 : : appropriate access. */
579 : 269728557 : if (TREE_PRIVATE (decl))
580 : : access = ak_private;
581 : 241520416 : else if (TREE_PROTECTED (decl))
582 : : access = ak_protected;
583 : : else
584 : 282090525 : access = ak_public;
585 : : }
586 : : else
587 : : {
588 : : /* First, check for an access-declaration that gives us more
589 : : access to the DECL. */
590 : 55339234 : if (DECL_LANG_SPECIFIC (decl) && !DECL_DISCRIMINATOR_P (decl))
591 : : {
592 : 77697498 : tree decl_access = purpose_member (type, DECL_ACCESS (decl));
593 : :
594 : 50957426 : if (decl_access)
595 : : {
596 : 541619 : decl_access = TREE_VALUE (decl_access);
597 : :
598 : 541619 : if (decl_access == access_public_node)
599 : : access = ak_public;
600 : 196997 : else if (decl_access == access_protected_node)
601 : : access = ak_protected;
602 : 33273 : else if (decl_access == access_private_node)
603 : : access = ak_private;
604 : : else
605 : 0 : gcc_unreachable ();
606 : : }
607 : : }
608 : :
609 : : if (!access)
610 : : {
611 : 54797615 : int i;
612 : 54797615 : tree base_binfo;
613 : 54797615 : vec<tree, va_gc> *accesses;
614 : :
615 : : /* Otherwise, scan our baseclasses, and pick the most favorable
616 : : access. */
617 : 54797615 : accesses = BINFO_BASE_ACCESSES (binfo);
618 : 60847900 : for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
619 : : {
620 : 54122007 : tree base_access = (*accesses)[i];
621 : 54122007 : access_kind base_access_now = BINFO_ACCESS (base_binfo);
622 : :
623 : 54122007 : if (base_access_now == ak_none || base_access_now == ak_private)
624 : : /* If it was not accessible in the base, or only
625 : : accessible as a private member, we can't access it
626 : : all. */
627 : : base_access_now = ak_none;
628 : 51307436 : else if (base_access == access_protected_node)
629 : : /* Public and protected members in the base become
630 : : protected here. */
631 : : base_access_now = ak_protected;
632 : 50880173 : else if (base_access == access_private_node)
633 : : /* Public and protected members in the base become
634 : : private here. */
635 : : base_access_now = ak_private;
636 : :
637 : : /* See if the new access, via this base, gives more
638 : : access than our previous best access. */
639 : 49753089 : if (base_access_now != ak_none
640 : 51307436 : && (access == ak_none || base_access_now < access))
641 : : {
642 : 51307106 : access = base_access_now;
643 : :
644 : : /* If the new access is public, we can't do better. */
645 : 51307106 : if (access == ak_public)
646 : : break;
647 : : }
648 : : }
649 : : }
650 : : }
651 : :
652 : : /* Note the access to DECL in TYPE. */
653 : 325067791 : SET_BINFO_ACCESS (binfo, access);
654 : :
655 : 325067791 : return NULL_TREE;
656 : : }
657 : :
658 : : /* Return the access to DECL in TYPE. */
659 : :
660 : : static access_kind
661 : 270269981 : access_in_type (tree type, tree decl)
662 : : {
663 : 270269981 : tree binfo = TYPE_BINFO (type);
664 : :
665 : : /* We must take into account
666 : :
667 : : [class.paths]
668 : :
669 : : If a name can be reached by several paths through a multiple
670 : : inheritance graph, the access is that of the path that gives
671 : : most access.
672 : :
673 : : The algorithm we use is to make a post-order depth-first traversal
674 : : of the base-class hierarchy. As we come up the tree, we annotate
675 : : each node with the most lenient access. */
676 : 270269981 : dfs_walk_once (binfo, dfs_access_in_type_pre, dfs_access_in_type, decl);
677 : :
678 : 270269981 : return BINFO_ACCESS (binfo);
679 : : }
680 : :
681 : : /* Returns nonzero if it is OK to access DECL named in TYPE through an object
682 : : of OTYPE in the context of DERIVED. */
683 : :
684 : : static int
685 : 8067836 : protected_accessible_p (tree decl, tree derived, tree type, tree otype)
686 : : {
687 : : /* We're checking this clause from [class.access.base]
688 : :
689 : : m as a member of N is protected, and the reference occurs in a
690 : : member or friend of class N, or in a member or friend of a
691 : : class P derived from N, where m as a member of P is public, private
692 : : or protected.
693 : :
694 : : Here DERIVED is a possible P, DECL is m and TYPE is N. */
695 : :
696 : : /* If DERIVED isn't derived from N, then it can't be a P. */
697 : 8067836 : if (!DERIVED_FROM_P (type, derived))
698 : : return 0;
699 : :
700 : : /* DECL_NONSTATIC_MEMBER_P won't work for USING_DECLs. */
701 : 8010280 : decl = strip_using_decl (decl);
702 : : /* We don't expect or support dependent decls. */
703 : 8010280 : gcc_assert (TREE_CODE (decl) != USING_DECL);
704 : :
705 : : /* [class.protected]
706 : :
707 : : When a friend or a member function of a derived class references
708 : : a protected non-static member of a base class, an access check
709 : : applies in addition to those described earlier in clause
710 : : _class.access_) Except when forming a pointer to member
711 : : (_expr.unary.op_), the access must be through a pointer to,
712 : : reference to, or object of the derived class itself (or any class
713 : : derived from that class) (_expr.ref_). If the access is to form
714 : : a pointer to member, the nested-name-specifier shall name the
715 : : derived class (or any class derived from that class). */
716 : 13520186 : if (DECL_NONSTATIC_MEMBER_P (decl)
717 : 12144542 : && !DERIVED_FROM_P (derived, otype))
718 : : return 0;
719 : :
720 : : return 1;
721 : : }
722 : :
723 : : /* Returns nonzero if SCOPE is a type or a friend of a type which would be able
724 : : to access DECL through TYPE. OTYPE is the type of the object. */
725 : :
726 : : static int
727 : 14119435 : friend_accessible_p (tree scope, tree decl, tree type, tree otype)
728 : : {
729 : : /* We're checking this clause from [class.access.base]
730 : :
731 : : m as a member of N is protected, and the reference occurs in a
732 : : member or friend of class N, or in a member or friend of a
733 : : class P derived from N, where m as a member of P is public, private
734 : : or protected.
735 : :
736 : : Here DECL is m and TYPE is N. SCOPE is the current context,
737 : : and we check all its possible Ps. */
738 : 14119435 : tree befriending_classes;
739 : 14119435 : tree t;
740 : :
741 : 14119435 : if (!scope)
742 : : return 0;
743 : :
744 : 14119435 : if (is_global_friend (scope))
745 : : return 1;
746 : :
747 : : /* Is SCOPE itself a suitable P? */
748 : 14119435 : if (TYPE_P (scope) && protected_accessible_p (decl, scope, type, otype))
749 : : return 1;
750 : :
751 : 6120381 : if (DECL_DECLARES_FUNCTION_P (scope))
752 : 6062485 : befriending_classes = DECL_BEFRIENDING_CLASSES (scope);
753 : 57896 : else if (TYPE_P (scope))
754 : 57116 : befriending_classes = CLASSTYPE_BEFRIENDING_CLASSES (scope);
755 : : else
756 : : return 0;
757 : :
758 : 6120146 : for (t = befriending_classes; t; t = TREE_CHAIN (t))
759 : 11666 : if (protected_accessible_p (decl, TREE_VALUE (t), type, otype))
760 : : return 1;
761 : :
762 : : /* Nested classes have the same access as their enclosing types, as
763 : : per DR 45 (this is a change from C++98). */
764 : 6108480 : if (TYPE_P (scope))
765 : 46523 : if (friend_accessible_p (TYPE_CONTEXT (scope), decl, type, otype))
766 : : return 1;
767 : :
768 : 6062520 : if (DECL_DECLARES_FUNCTION_P (scope))
769 : : {
770 : : /* Perhaps this SCOPE is a member of a class which is a
771 : : friend. */
772 : 12123914 : if (DECL_CLASS_SCOPE_P (scope)
773 : 12123530 : && friend_accessible_p (DECL_CONTEXT (scope), decl, type, otype))
774 : : return 1;
775 : : /* Perhaps SCOPE is a friend function defined inside a class from which
776 : : DECL is accessible. */
777 : 1016 : if (tree fctx = DECL_FRIEND_CONTEXT (scope))
778 : 4 : if (friend_accessible_p (fctx, decl, type, otype))
779 : : return 1;
780 : : }
781 : :
782 : : /* Maybe scope's template is a friend. */
783 : 1067 : if (tree tinfo = get_template_info (scope))
784 : : {
785 : 762 : tree tmpl = TI_TEMPLATE (tinfo);
786 : 762 : if (DECL_CLASS_TEMPLATE_P (tmpl))
787 : 479 : tmpl = TREE_TYPE (tmpl);
788 : : else
789 : 283 : tmpl = DECL_TEMPLATE_RESULT (tmpl);
790 : 762 : if (tmpl != scope)
791 : : {
792 : : /* Increment processing_template_decl to make sure that
793 : : dependent_type_p works correctly. */
794 : 598 : ++processing_template_decl;
795 : 598 : int ret = friend_accessible_p (tmpl, decl, type, otype);
796 : 598 : --processing_template_decl;
797 : 598 : if (ret)
798 : : return 1;
799 : : }
800 : : }
801 : :
802 : : /* If is_friend is true, we should have found a befriending class. */
803 : 513 : gcc_checking_assert (!is_friend (type, scope));
804 : :
805 : : return 0;
806 : : }
807 : :
808 : : struct dfs_accessible_data
809 : : {
810 : : tree decl;
811 : : tree object_type;
812 : : };
813 : :
814 : : /* Avoid walking up past a declaration of the member. */
815 : :
816 : : static tree
817 : 41328486 : dfs_accessible_pre (tree binfo, void *data)
818 : : {
819 : 41328486 : dfs_accessible_data *d = (dfs_accessible_data *)data;
820 : 41328486 : tree type = BINFO_TYPE (binfo);
821 : 41328486 : if (member_declared_in_type (d->decl, type))
822 : 37447252 : return dfs_skip_bases;
823 : : return NULL_TREE;
824 : : }
825 : :
826 : : /* Called via dfs_walk_once_accessible from accessible_p */
827 : :
828 : : static tree
829 : 38013714 : dfs_accessible_post (tree binfo, void *data)
830 : : {
831 : : /* access_in_type already set BINFO_ACCESS for us. */
832 : 38013714 : access_kind access = BINFO_ACCESS (binfo);
833 : 38013714 : tree N = BINFO_TYPE (binfo);
834 : 38013714 : dfs_accessible_data *d = (dfs_accessible_data *)data;
835 : 38013714 : tree decl = d->decl;
836 : 38013714 : tree scope = current_nonlambda_scope ();
837 : :
838 : : /* A member m is accessible at the point R when named in class N if */
839 : 38013714 : switch (access)
840 : : {
841 : : case ak_none:
842 : : return NULL_TREE;
843 : :
844 : : case ak_public:
845 : : /* m as a member of N is public, or */
846 : : return binfo;
847 : :
848 : 28241288 : case ak_private:
849 : 28241288 : {
850 : : /* m as a member of N is private, and R occurs in a member or friend of
851 : : class N, or */
852 : 28241288 : if (scope && TREE_CODE (scope) != NAMESPACE_DECL
853 : 56482246 : && is_friend (N, scope))
854 : : return binfo;
855 : : return NULL_TREE;
856 : : }
857 : :
858 : 8010737 : case ak_protected:
859 : 8010737 : {
860 : : /* m as a member of N is protected, and R occurs in a member or friend
861 : : of class N, or in a member or friend of a class P derived from N,
862 : : where m as a member of P is public, private, or protected */
863 : 8010737 : if (friend_accessible_p (scope, decl, N, d->object_type))
864 : : return binfo;
865 : : return NULL_TREE;
866 : : }
867 : :
868 : : default:
869 : : gcc_unreachable ();
870 : : }
871 : : }
872 : :
873 : : /* Like accessible_p below, but within a template returns true iff DECL is
874 : : accessible in TYPE to all possible instantiations of the template. */
875 : :
876 : : int
877 : 5100016 : accessible_in_template_p (tree type, tree decl)
878 : : {
879 : 5100016 : int save_ptd = processing_template_decl;
880 : 5100016 : processing_template_decl = 0;
881 : 5100016 : int val = accessible_p (type, decl, false);
882 : 5100016 : processing_template_decl = save_ptd;
883 : 5100016 : return val;
884 : : }
885 : :
886 : : /* DECL is a declaration from a base class of TYPE, which was the
887 : : class used to name DECL. Return nonzero if, in the current
888 : : context, DECL is accessible. If TYPE is actually a BINFO node,
889 : : then we can tell in what context the access is occurring by looking
890 : : at the most derived class along the path indicated by BINFO. If
891 : : CONSIDER_LOCAL is true, do consider special access the current
892 : : scope or friendship thereof we might have. */
893 : :
894 : : int
895 : 270269694 : accessible_p (tree type, tree decl, bool consider_local_p)
896 : : {
897 : 270269694 : tree binfo;
898 : 270269694 : access_kind access;
899 : :
900 : : /* If this declaration is in a block or namespace scope, there's no
901 : : access control. */
902 : 270269694 : if (!TYPE_P (context_for_name_lookup (decl)))
903 : : return 1;
904 : :
905 : : /* There is no need to perform access checks inside a thunk. */
906 : 270269639 : if (current_function_decl && DECL_THUNK_P (current_function_decl))
907 : : return 1;
908 : :
909 : 270269639 : tree otype = NULL_TREE;
910 : 270269639 : if (!TYPE_P (type))
911 : : {
912 : : /* When accessing a non-static member, the most derived type in the
913 : : binfo chain is the type of the object; remember that type for
914 : : protected_accessible_p. */
915 : 530588643 : for (tree b = type; b; b = BINFO_INHERITANCE_CHAIN (b))
916 : 273387074 : otype = BINFO_TYPE (b);
917 : 257201569 : type = BINFO_TYPE (type);
918 : : }
919 : : else
920 : : otype = type;
921 : :
922 : : /* Anonymous unions don't have their own access. */
923 : 270269639 : if (ANON_AGGR_TYPE_P (type))
924 : 3 : type = type_context_for_name_lookup (type);
925 : :
926 : : /* [class.access.base]
927 : :
928 : : A member m is accessible when named in class N if
929 : :
930 : : --m as a member of N is public, or
931 : :
932 : : --m as a member of N is private, and the reference occurs in a
933 : : member or friend of class N, or
934 : :
935 : : --m as a member of N is protected, and the reference occurs in a
936 : : member or friend of class N, or in a member or friend of a
937 : : class P derived from N, where m as a member of P is public, private or
938 : : protected, or
939 : :
940 : : --there exists a base class B of N that is accessible at the point
941 : : of reference, and m is accessible when named in class B.
942 : :
943 : : We walk the base class hierarchy, checking these conditions. */
944 : :
945 : : /* We walk using TYPE_BINFO (type) because access_in_type will set
946 : : BINFO_ACCESS on it and its bases. */
947 : 270269639 : binfo = TYPE_BINFO (type);
948 : :
949 : : /* Compute the accessibility of DECL in the class hierarchy
950 : : dominated by type. */
951 : 270269639 : access = access_in_type (type, decl);
952 : 270269639 : if (access == ak_public)
953 : : return 1;
954 : :
955 : : /* If we aren't considering the point of reference, only the first bullet
956 : : applies. */
957 : 37448773 : if (!consider_local_p)
958 : : return 0;
959 : :
960 : 37448391 : dfs_accessible_data d = { decl, otype };
961 : :
962 : : /* Walk the hierarchy again, looking for a base class that allows
963 : : access. */
964 : 37448391 : return dfs_walk_once_accessible (binfo, /*friends=*/true,
965 : : dfs_accessible_pre,
966 : : dfs_accessible_post, &d)
967 : 37448391 : != NULL_TREE;
968 : : }
969 : :
970 : : struct lookup_field_info {
971 : : /* The type in which we're looking. */
972 : : tree type;
973 : : /* The name of the field for which we're looking. */
974 : : tree name;
975 : : /* If non-NULL, the current result of the lookup. */
976 : : tree rval;
977 : : /* The path to RVAL. */
978 : : tree rval_binfo;
979 : : /* If non-NULL, the lookup was ambiguous, and this is a list of the
980 : : candidates. */
981 : : tree ambiguous;
982 : : /* If nonzero, we are looking for types, not data members. */
983 : : int want_type;
984 : : };
985 : :
986 : : /* True for a class member means that it is shared between all objects
987 : : of that class.
988 : :
989 : : [class.member.lookup]:If the resulting set of declarations are not all
990 : : from sub-objects of the same type, or the set has a non-static member
991 : : and includes members from distinct sub-objects, there is an ambiguity
992 : : and the program is ill-formed.
993 : :
994 : : This function checks that T contains no non-static members. */
995 : :
996 : : bool
997 : 40146866 : shared_member_p (tree t)
998 : : {
999 : 40146866 : if (VAR_P (t) || TREE_CODE (t) == TYPE_DECL
1000 : 37297039 : || TREE_CODE (t) == CONST_DECL)
1001 : : return true;
1002 : 37293639 : if (is_overloaded_fn (t))
1003 : : {
1004 : 64049488 : for (ovl_iterator iter (get_fns (t)); iter; ++iter)
1005 : : {
1006 : 40726088 : tree decl = strip_using_decl (*iter);
1007 : 40726088 : if (TREE_CODE (decl) == USING_DECL)
1008 : : /* Conservatively assume a dependent using-declaration
1009 : : might resolve to a non-static member. */
1010 : 23399228 : return false;
1011 : 40726084 : if (DECL_OBJECT_MEMBER_FUNCTION_P (decl))
1012 : : return false;
1013 : : }
1014 : 13894043 : return true;
1015 : : }
1016 : : return false;
1017 : : }
1018 : :
1019 : : /* Routine to see if the sub-object denoted by the binfo PARENT can be
1020 : : found as a base class and sub-object of the object denoted by
1021 : : BINFO. */
1022 : :
1023 : : static int
1024 : 6636908 : is_subobject_of_p (tree parent, tree binfo)
1025 : : {
1026 : 6636908 : tree probe;
1027 : :
1028 : 18384663 : for (probe = parent; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1029 : : {
1030 : 13427811 : if (probe == binfo)
1031 : : return 1;
1032 : 13388604 : if (BINFO_VIRTUAL_P (probe))
1033 : 1640849 : return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (binfo))
1034 : 1640849 : != NULL_TREE);
1035 : : }
1036 : : return 0;
1037 : : }
1038 : :
1039 : : /* DATA is really a struct lookup_field_info. Look for a field with
1040 : : the name indicated there in BINFO. If this function returns a
1041 : : non-NULL value it is the result of the lookup. Called from
1042 : : lookup_field via breadth_first_search. */
1043 : :
1044 : : static tree
1045 : 5510999522 : lookup_field_r (tree binfo, void *data)
1046 : : {
1047 : 5510999522 : struct lookup_field_info *lfi = (struct lookup_field_info *) data;
1048 : 5510999522 : tree type = BINFO_TYPE (binfo);
1049 : 5510999522 : tree nval = NULL_TREE;
1050 : :
1051 : : /* If this is a dependent base, don't look in it. */
1052 : 5510999522 : if (BINFO_DEPENDENT_BASE_P (binfo))
1053 : : return NULL_TREE;
1054 : :
1055 : : /* If this base class is hidden by the best-known value so far, we
1056 : : don't need to look. */
1057 : 77239807 : if (lfi->rval_binfo && BINFO_INHERITANCE_CHAIN (binfo) == lfi->rval_binfo
1058 : 4398842594 : && !BINFO_VIRTUAL_P (binfo))
1059 : : return dfs_skip_bases;
1060 : :
1061 : 4282181099 : nval = get_class_binding (type, lfi->name, lfi->want_type);
1062 : :
1063 : : /* If there is no declaration with the indicated name in this type,
1064 : : then there's nothing to do. */
1065 : 4282181099 : if (!nval)
1066 : 3781658251 : goto done;
1067 : :
1068 : : /* If the lookup already found a match, and the new value doesn't
1069 : : hide the old one, we might have an ambiguity. */
1070 : 500522848 : if (lfi->rval_binfo
1071 : 500522848 : && !is_subobject_of_p (lfi->rval_binfo, binfo))
1072 : :
1073 : : {
1074 : 3298963 : if (nval == lfi->rval && shared_member_p (nval))
1075 : : /* The two things are really the same. */
1076 : : ;
1077 : 3298695 : else if (is_subobject_of_p (binfo, lfi->rval_binfo))
1078 : : /* The previous value hides the new one. */
1079 : : ;
1080 : : else
1081 : : {
1082 : : /* We have a real ambiguity. We keep a chain of all the
1083 : : candidates. */
1084 : 1702138 : if (!lfi->ambiguous && lfi->rval)
1085 : : {
1086 : : /* This is the first time we noticed an ambiguity. Add
1087 : : what we previously thought was a reasonable candidate
1088 : : to the list. */
1089 : 882571 : lfi->ambiguous = tree_cons (NULL_TREE, lfi->rval, NULL_TREE);
1090 : 882571 : TREE_TYPE (lfi->ambiguous) = error_mark_node;
1091 : : }
1092 : :
1093 : : /* Add the new value. */
1094 : 1702138 : if (TREE_CODE (nval) == TREE_LIST)
1095 : 6 : lfi->ambiguous = chainon (nval, lfi->ambiguous);
1096 : : else
1097 : : {
1098 : 1702132 : lfi->ambiguous = tree_cons (NULL_TREE, nval, lfi->ambiguous);
1099 : 1702132 : TREE_TYPE (lfi->ambiguous) = error_mark_node;
1100 : : }
1101 : : }
1102 : : }
1103 : : else
1104 : : {
1105 : 497223885 : if (TREE_CODE (nval) == TREE_LIST)
1106 : : {
1107 : 97 : lfi->ambiguous = chainon (nval, lfi->ambiguous);
1108 : 97 : lfi->rval = TREE_VALUE (nval);
1109 : : }
1110 : : else
1111 : 497223788 : lfi->rval = nval;
1112 : 497223885 : lfi->rval_binfo = binfo;
1113 : : }
1114 : :
1115 : 4282181099 : done:
1116 : : /* Don't look for constructors or destructors in base classes. */
1117 : 4282181099 : if (IDENTIFIER_CDTOR_P (lfi->name))
1118 : : return dfs_skip_bases;
1119 : : return NULL_TREE;
1120 : : }
1121 : :
1122 : : /* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO,
1123 : : BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO,
1124 : : FUNCTIONS, and OPTYPE respectively. */
1125 : :
1126 : : tree
1127 : 164213096 : build_baselink (tree binfo, tree access_binfo, tree functions, tree optype)
1128 : : {
1129 : 164213096 : tree baselink;
1130 : :
1131 : 164213096 : gcc_assert (OVL_P (functions) || TREE_CODE (functions) == TEMPLATE_ID_EXPR);
1132 : 164213096 : gcc_assert (!optype || TYPE_P (optype));
1133 : 164213096 : gcc_assert (TREE_TYPE (functions));
1134 : :
1135 : 164213096 : baselink = make_node (BASELINK);
1136 : 164213096 : TREE_TYPE (baselink) = TREE_TYPE (functions);
1137 : 164213096 : BASELINK_BINFO (baselink) = binfo;
1138 : 164213096 : BASELINK_ACCESS_BINFO (baselink) = access_binfo;
1139 : 164213096 : BASELINK_FUNCTIONS (baselink) = functions;
1140 : 164213096 : BASELINK_OPTYPE (baselink) = optype;
1141 : :
1142 : 164213096 : if (binfo == access_binfo
1143 : 319652709 : && TYPE_BEING_DEFINED (BINFO_TYPE (access_binfo)))
1144 : 3567066 : BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P (baselink) = true;
1145 : :
1146 : 164213096 : return baselink;
1147 : : }
1148 : :
1149 : : /* Look for a member named NAME in an inheritance lattice dominated by
1150 : : XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
1151 : : is 1, we enforce accessibility. If PROTECT is zero, then, for an
1152 : : ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
1153 : : messages about inaccessible or ambiguous lookup. If PROTECT is 2,
1154 : : we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
1155 : : TREE_VALUEs are the list of ambiguous candidates.
1156 : :
1157 : : WANT_TYPE is 1 when we should only return TYPE_DECLs.
1158 : :
1159 : : If nothing can be found return NULL_TREE and do not issue an error.
1160 : :
1161 : : If non-NULL, failure information is written back to AFI. */
1162 : :
1163 : : tree
1164 : 3623537337 : lookup_member (tree xbasetype, tree name, int protect, bool want_type,
1165 : : tsubst_flags_t complain, access_failure_info *afi /* = NULL */)
1166 : : {
1167 : 3623537337 : tree rval, rval_binfo = NULL_TREE;
1168 : 3623537337 : tree type = NULL_TREE, basetype_path = NULL_TREE;
1169 : 3623537337 : struct lookup_field_info lfi;
1170 : :
1171 : : /* rval_binfo is the binfo associated with the found member, note,
1172 : : this can be set with useful information, even when rval is not
1173 : : set, because it must deal with ALL members, not just non-function
1174 : : members. It is used for ambiguity checking and the hidden
1175 : : checks. Whereas rval is only set if a proper (not hidden)
1176 : : non-function member is found. */
1177 : :
1178 : 3623537337 : if (name == error_mark_node
1179 : 3623537337 : || xbasetype == NULL_TREE
1180 : 3623537329 : || xbasetype == error_mark_node)
1181 : : return NULL_TREE;
1182 : :
1183 : 3623537329 : gcc_assert (identifier_p (name));
1184 : :
1185 : 3623537329 : if (TREE_CODE (xbasetype) == TREE_BINFO)
1186 : : {
1187 : 75987125 : type = BINFO_TYPE (xbasetype);
1188 : 75987125 : basetype_path = xbasetype;
1189 : : }
1190 : : else
1191 : : {
1192 : 3547550204 : if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype)))
1193 : : return NULL_TREE;
1194 : : type = xbasetype;
1195 : 3623537305 : xbasetype = NULL_TREE;
1196 : : }
1197 : :
1198 : 3623537305 : type = complete_type (type);
1199 : :
1200 : : /* Make sure we're looking for a member of the current instantiation in the
1201 : : right partial specialization. */
1202 : 3623537241 : if (dependent_type_p (type))
1203 : 2483875439 : if (tree t = currently_open_class (type))
1204 : 3623537241 : type = t;
1205 : :
1206 : 3623537241 : if (!basetype_path)
1207 : 3547550116 : basetype_path = TYPE_BINFO (type);
1208 : :
1209 : 3547550116 : if (!basetype_path)
1210 : : return NULL_TREE;
1211 : :
1212 : 3550571418 : memset (&lfi, 0, sizeof (lfi));
1213 : 3550571418 : lfi.type = type;
1214 : 3550571418 : lfi.name = name;
1215 : 3550571418 : lfi.want_type = want_type;
1216 : 3550571418 : dfs_walk_all (basetype_path, &lookup_field_r, NULL, &lfi);
1217 : 3550571418 : rval = lfi.rval;
1218 : 3550571418 : rval_binfo = lfi.rval_binfo;
1219 : 3550571418 : if (rval_binfo)
1220 : 497184635 : type = BINFO_TYPE (rval_binfo);
1221 : :
1222 : 3550571418 : if (lfi.ambiguous)
1223 : : {
1224 : 882668 : if (protect == 0)
1225 : : return NULL_TREE;
1226 : 882650 : else if (protect == 1)
1227 : : {
1228 : 85 : if (complain & tf_error)
1229 : : {
1230 : 74 : error ("request for member %qD is ambiguous", name);
1231 : 74 : print_candidates (lfi.ambiguous);
1232 : : }
1233 : 85 : return error_mark_node;
1234 : : }
1235 : 882565 : else if (protect == 2)
1236 : : return lfi.ambiguous;
1237 : : }
1238 : :
1239 : 3549688750 : if (!rval)
1240 : : return NULL_TREE;
1241 : :
1242 : : /* [class.access]
1243 : :
1244 : : In the case of overloaded function names, access control is
1245 : : applied to the function selected by overloaded resolution.
1246 : :
1247 : : We cannot check here, even if RVAL is only a single non-static
1248 : : member function, since we do not know what the "this" pointer
1249 : : will be. For:
1250 : :
1251 : : class A { protected: void f(); };
1252 : : class B : public A {
1253 : : void g(A *p) {
1254 : : f(); // OK
1255 : : p->f(); // Not OK.
1256 : : }
1257 : : };
1258 : :
1259 : : only the first call to "f" is valid. However, if the function is
1260 : : static, we can check. */
1261 : 496301967 : if (protect == 1 && !really_overloaded_fn (rval))
1262 : : {
1263 : 79557113 : tree decl = is_overloaded_fn (rval) ? get_first_fn (rval) : rval;
1264 : 79557113 : decl = strip_using_decl (decl);
1265 : : /* A dependent USING_DECL will be checked after tsubsting. */
1266 : 79557113 : if (TREE_CODE (decl) != USING_DECL
1267 : 74662402 : && !DECL_IOBJ_MEMBER_FUNCTION_P (decl)
1268 : 115993448 : && !perform_or_defer_access_check (basetype_path, decl, decl,
1269 : : complain, afi))
1270 : 70 : return error_mark_node;
1271 : : }
1272 : :
1273 : 496301897 : if (is_overloaded_fn (rval)
1274 : : /* Don't use a BASELINK for class-scope deduction guides since
1275 : : they're not actually member functions. */
1276 : 496301897 : && !dguide_name_p (name))
1277 : 305604646 : rval = build_baselink (rval_binfo, basetype_path, rval,
1278 : 292340451 : (IDENTIFIER_CONV_OP_P (name)
1279 : 286855 : ? TREE_TYPE (name): NULL_TREE));
1280 : : return rval;
1281 : : }
1282 : :
1283 : : /* Helper class for lookup_member_fuzzy. */
1284 : :
1285 : 681 : class lookup_field_fuzzy_info
1286 : : {
1287 : : public:
1288 : 681 : lookup_field_fuzzy_info (bool want_type_p) :
1289 : 681 : m_want_type_p (want_type_p), m_candidates () {}
1290 : :
1291 : : void fuzzy_lookup_field (tree type);
1292 : :
1293 : : /* If true, we are looking for types, not data members. */
1294 : : bool m_want_type_p;
1295 : : /* The result: a vec of identifiers. */
1296 : : auto_vec<tree> m_candidates;
1297 : : };
1298 : :
1299 : : /* Locate all fields within TYPE, append them to m_candidates. */
1300 : :
1301 : : void
1302 : 777 : lookup_field_fuzzy_info::fuzzy_lookup_field (tree type)
1303 : : {
1304 : 777 : if (!CLASS_TYPE_P (type))
1305 : : return;
1306 : :
1307 : 4135 : for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1308 : : {
1309 : 3364 : if (m_want_type_p && !DECL_DECLARES_TYPE_P (field))
1310 : 141 : continue;
1311 : :
1312 : 3223 : if (!DECL_NAME (field))
1313 : 86 : continue;
1314 : :
1315 : 3137 : if (is_lambda_ignored_entity (field))
1316 : 36 : continue;
1317 : :
1318 : : /* Ignore special identifiers with space at the end like cdtor or
1319 : : conversion op identifiers. */
1320 : 3101 : if (TREE_CODE (DECL_NAME (field)) == IDENTIFIER_NODE)
1321 : 3101 : if (unsigned int len = IDENTIFIER_LENGTH (DECL_NAME (field)))
1322 : 3101 : if (IDENTIFIER_POINTER (DECL_NAME (field))[len - 1] == ' ')
1323 : 1528 : continue;
1324 : :
1325 : 1573 : m_candidates.safe_push (DECL_NAME (field));
1326 : : }
1327 : : }
1328 : :
1329 : :
1330 : : /* Helper function for lookup_member_fuzzy, called via dfs_walk_all
1331 : : DATA is really a lookup_field_fuzzy_info. Look for a field with
1332 : : the name indicated there in BINFO. Gathers pertinent identifiers into
1333 : : m_candidates. */
1334 : :
1335 : : static tree
1336 : 777 : lookup_field_fuzzy_r (tree binfo, void *data)
1337 : : {
1338 : 777 : lookup_field_fuzzy_info *lffi = (lookup_field_fuzzy_info *) data;
1339 : 777 : tree type = BINFO_TYPE (binfo);
1340 : :
1341 : 777 : lffi->fuzzy_lookup_field (type);
1342 : :
1343 : 777 : return NULL_TREE;
1344 : : }
1345 : :
1346 : : /* Like lookup_member, but try to find the closest match for NAME,
1347 : : rather than an exact match, and return an identifier (or NULL_TREE).
1348 : : Do not complain. */
1349 : :
1350 : : tree
1351 : 681 : lookup_member_fuzzy (tree xbasetype, tree name, bool want_type_p)
1352 : : {
1353 : 681 : tree type = NULL_TREE, basetype_path = NULL_TREE;
1354 : 681 : class lookup_field_fuzzy_info lffi (want_type_p);
1355 : :
1356 : : /* rval_binfo is the binfo associated with the found member, note,
1357 : : this can be set with useful information, even when rval is not
1358 : : set, because it must deal with ALL members, not just non-function
1359 : : members. It is used for ambiguity checking and the hidden
1360 : : checks. Whereas rval is only set if a proper (not hidden)
1361 : : non-function member is found. */
1362 : :
1363 : 681 : if (name == error_mark_node
1364 : 681 : || xbasetype == NULL_TREE
1365 : 681 : || xbasetype == error_mark_node)
1366 : : return NULL_TREE;
1367 : :
1368 : 681 : gcc_assert (identifier_p (name));
1369 : :
1370 : 681 : if (TREE_CODE (xbasetype) == TREE_BINFO)
1371 : : {
1372 : 8 : type = BINFO_TYPE (xbasetype);
1373 : 8 : basetype_path = xbasetype;
1374 : : }
1375 : : else
1376 : : {
1377 : 673 : if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype)))
1378 : : return NULL_TREE;
1379 : : type = xbasetype;
1380 : 681 : xbasetype = NULL_TREE;
1381 : : }
1382 : :
1383 : 681 : type = complete_type (type);
1384 : :
1385 : : /* Make sure we're looking for a member of the current instantiation in the
1386 : : right partial specialization. */
1387 : 681 : if (flag_concepts && dependent_type_p (type))
1388 : 39 : type = currently_open_class (type);
1389 : :
1390 : 681 : if (!basetype_path)
1391 : 673 : basetype_path = TYPE_BINFO (type);
1392 : :
1393 : 673 : if (!basetype_path)
1394 : : return NULL_TREE;
1395 : :
1396 : : /* Populate lffi.m_candidates. */
1397 : 673 : dfs_walk_all (basetype_path, &lookup_field_fuzzy_r, NULL, &lffi);
1398 : :
1399 : 673 : return find_closest_identifier (name, &lffi.m_candidates);
1400 : 681 : }
1401 : :
1402 : : /* Like lookup_member, except that if we find a function member we
1403 : : return NULL_TREE. */
1404 : :
1405 : : tree
1406 : 21203094 : lookup_field (tree xbasetype, tree name, int protect, bool want_type)
1407 : : {
1408 : 21203094 : tree rval = lookup_member (xbasetype, name, protect, want_type,
1409 : : tf_warning_or_error);
1410 : :
1411 : : /* Ignore functions, but propagate the ambiguity list. */
1412 : 21203094 : if (!error_operand_p (rval)
1413 : 21203094 : && (rval && BASELINK_P (rval)))
1414 : 0 : return NULL_TREE;
1415 : :
1416 : : return rval;
1417 : : }
1418 : :
1419 : : /* Like lookup_member, except that if we find a non-function member we
1420 : : return NULL_TREE. */
1421 : :
1422 : : tree
1423 : 93504522 : lookup_fnfields (tree xbasetype, tree name, int protect,
1424 : : tsubst_flags_t complain)
1425 : : {
1426 : 93504522 : tree rval = lookup_member (xbasetype, name, protect, /*want_type=*/false,
1427 : : complain);
1428 : :
1429 : : /* Ignore non-functions, but propagate the ambiguity list. */
1430 : 93504522 : if (!error_operand_p (rval)
1431 : 93504522 : && (rval && !BASELINK_P (rval)))
1432 : 0 : return NULL_TREE;
1433 : :
1434 : : return rval;
1435 : : }
1436 : :
1437 : : /* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
1438 : : the class or namespace used to qualify the name. CONTEXT_CLASS is
1439 : : the class corresponding to the object in which DECL will be used.
1440 : : Return a possibly modified version of DECL that takes into account
1441 : : the CONTEXT_CLASS.
1442 : :
1443 : : In particular, consider an expression like `B::m' in the context of
1444 : : a derived class `D'. If `B::m' has been resolved to a BASELINK,
1445 : : then the most derived class indicated by the BASELINK_BINFO will be
1446 : : `B', not `D'. This function makes that adjustment. */
1447 : :
1448 : : tree
1449 : 119053462 : adjust_result_of_qualified_name_lookup (tree decl,
1450 : : tree qualifying_scope,
1451 : : tree context_class)
1452 : : {
1453 : 83145644 : if (context_class && context_class != error_mark_node
1454 : 83145632 : && CLASS_TYPE_P (context_class)
1455 : 83145624 : && CLASS_TYPE_P (qualifying_scope)
1456 : 48838511 : && DERIVED_FROM_P (qualifying_scope, context_class)
1457 : 121886884 : && BASELINK_P (decl))
1458 : : {
1459 : 2733299 : tree base;
1460 : :
1461 : : /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
1462 : : Because we do not yet know which function will be chosen by
1463 : : overload resolution, we cannot yet check either accessibility
1464 : : or ambiguity -- in either case, the choice of a static member
1465 : : function might make the usage valid. */
1466 : 2733299 : base = lookup_base (context_class, qualifying_scope,
1467 : : ba_unique, NULL, tf_none);
1468 : 2733299 : if (base && base != error_mark_node)
1469 : : {
1470 : 2733291 : BASELINK_ACCESS_BINFO (decl) = base;
1471 : 2733291 : tree decl_binfo
1472 : 2733291 : = lookup_base (base, BINFO_TYPE (BASELINK_BINFO (decl)),
1473 : : ba_unique, NULL, tf_none);
1474 : 2733291 : if (decl_binfo && decl_binfo != error_mark_node)
1475 : 2733283 : BASELINK_BINFO (decl) = decl_binfo;
1476 : : }
1477 : : }
1478 : :
1479 : 119053462 : if (BASELINK_P (decl))
1480 : 16686173 : BASELINK_QUALIFIED_P (decl) = true;
1481 : :
1482 : 119053462 : return decl;
1483 : : }
1484 : :
1485 : :
1486 : : /* Walk the class hierarchy within BINFO, in a depth-first traversal.
1487 : : PRE_FN is called in preorder, while POST_FN is called in postorder.
1488 : : If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
1489 : : walked. If PRE_FN or POST_FN returns a different non-NULL value,
1490 : : that value is immediately returned and the walk is terminated. One
1491 : : of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
1492 : : POST_FN are passed the binfo to examine and the caller's DATA
1493 : : value. All paths are walked, thus virtual and morally virtual
1494 : : binfos can be multiply walked. */
1495 : :
1496 : : tree
1497 : 6668254771 : dfs_walk_all (tree binfo, tree (*pre_fn) (tree, void *),
1498 : : tree (*post_fn) (tree, void *), void *data)
1499 : : {
1500 : 6668254771 : tree rval;
1501 : 6668254771 : unsigned ix;
1502 : 6668254771 : tree base_binfo;
1503 : :
1504 : : /* Call the pre-order walking function. */
1505 : 6668254771 : if (pre_fn)
1506 : : {
1507 : 6664056090 : rval = pre_fn (binfo, data);
1508 : 6664056090 : if (rval)
1509 : : {
1510 : 867422538 : if (rval == dfs_skip_bases)
1511 : 521551318 : goto skip_bases;
1512 : : return rval;
1513 : : }
1514 : : }
1515 : :
1516 : : /* Find the next child binfo to walk. */
1517 : 7950071824 : for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1518 : : {
1519 : 2220502250 : rval = dfs_walk_all (base_binfo, pre_fn, post_fn, data);
1520 : 2220502250 : if (rval)
1521 : 71262659 : return rval;
1522 : : }
1523 : :
1524 : 6251120892 : skip_bases:
1525 : : /* Call the post-order walking function. */
1526 : 6251120892 : if (post_fn)
1527 : : {
1528 : 356468061 : rval = post_fn (binfo, data);
1529 : 356468061 : gcc_assert (rval != dfs_skip_bases);
1530 : : return rval;
1531 : : }
1532 : :
1533 : : return NULL_TREE;
1534 : : }
1535 : :
1536 : : /* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1537 : : that binfos are walked at most once. */
1538 : :
1539 : : static tree
1540 : 2640352 : dfs_walk_once_r (tree binfo, tree (*pre_fn) (tree, void *),
1541 : : tree (*post_fn) (tree, void *), hash_set<tree> *pset,
1542 : : void *data)
1543 : : {
1544 : 2640352 : tree rval;
1545 : 2640352 : unsigned ix;
1546 : 2640352 : tree base_binfo;
1547 : :
1548 : : /* Call the pre-order walking function. */
1549 : 2640352 : if (pre_fn)
1550 : : {
1551 : 2306646 : rval = pre_fn (binfo, data);
1552 : 2306646 : if (rval)
1553 : : {
1554 : 525181 : if (rval == dfs_skip_bases)
1555 : 141858 : goto skip_bases;
1556 : :
1557 : : return rval;
1558 : : }
1559 : : }
1560 : :
1561 : : /* Find the next child binfo to walk. */
1562 : 3933101 : for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1563 : : {
1564 : 2301491 : if (BINFO_VIRTUAL_P (base_binfo))
1565 : 915187 : if (pset->add (base_binfo))
1566 : 395139 : continue;
1567 : :
1568 : 1906352 : rval = dfs_walk_once_r (base_binfo, pre_fn, post_fn, pset, data);
1569 : 1906352 : if (rval)
1570 : 483561 : return rval;
1571 : : }
1572 : :
1573 : 1773468 : skip_bases:
1574 : : /* Call the post-order walking function. */
1575 : 1773468 : if (post_fn)
1576 : : {
1577 : 492793 : rval = post_fn (binfo, data);
1578 : 492793 : gcc_assert (rval != dfs_skip_bases);
1579 : : return rval;
1580 : : }
1581 : :
1582 : : return NULL_TREE;
1583 : : }
1584 : :
1585 : : /* Like dfs_walk_all, except that binfos are not multiply walked. For
1586 : : non-diamond shaped hierarchies this is the same as dfs_walk_all.
1587 : : For diamond shaped hierarchies we must mark the virtual bases, to
1588 : : avoid multiple walks. */
1589 : :
1590 : : tree
1591 : 889171144 : dfs_walk_once (tree binfo, tree (*pre_fn) (tree, void *),
1592 : : tree (*post_fn) (tree, void *), void *data)
1593 : : {
1594 : 889171144 : static int active = 0; /* We must not be called recursively. */
1595 : 889171144 : tree rval;
1596 : :
1597 : 889171144 : gcc_assert (pre_fn || post_fn);
1598 : 889171144 : gcc_assert (!active);
1599 : 889171144 : active++;
1600 : :
1601 : 889171144 : if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo)))
1602 : : /* We are not diamond shaped, and therefore cannot encounter the
1603 : : same binfo twice. */
1604 : 888437144 : rval = dfs_walk_all (binfo, pre_fn, post_fn, data);
1605 : : else
1606 : : {
1607 : 734000 : hash_set<tree> pset;
1608 : 734000 : rval = dfs_walk_once_r (binfo, pre_fn, post_fn, &pset, data);
1609 : 734000 : }
1610 : :
1611 : 889171144 : active--;
1612 : :
1613 : 889171144 : return rval;
1614 : : }
1615 : :
1616 : : /* Worker function for dfs_walk_once_accessible. Behaves like
1617 : : dfs_walk_once_r, except (a) FRIENDS_P is true if special
1618 : : access given by the current context should be considered, (b) ONCE
1619 : : indicates whether bases should be marked during traversal. */
1620 : :
1621 : : static tree
1622 : 41343735 : dfs_walk_once_accessible_r (tree binfo, bool friends_p, hash_set<tree> *pset,
1623 : : tree (*pre_fn) (tree, void *),
1624 : : tree (*post_fn) (tree, void *), void *data)
1625 : : {
1626 : 41343735 : tree rval = NULL_TREE;
1627 : 41343735 : unsigned ix;
1628 : 41343735 : tree base_binfo;
1629 : :
1630 : : /* Call the pre-order walking function. */
1631 : 41343735 : if (pre_fn)
1632 : : {
1633 : 41343735 : rval = pre_fn (binfo, data);
1634 : 41343735 : if (rval)
1635 : : {
1636 : 37454284 : if (rval == dfs_skip_bases)
1637 : 37447324 : goto skip_bases;
1638 : :
1639 : : return rval;
1640 : : }
1641 : : }
1642 : :
1643 : : /* Find the next child binfo to walk. */
1644 : 4482906 : for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1645 : : {
1646 : 3915505 : bool mark = pset && BINFO_VIRTUAL_P (base_binfo);
1647 : :
1648 : 10202 : if (mark && pset->contains (base_binfo))
1649 : 0 : continue;
1650 : :
1651 : : /* If the base is inherited via private or protected
1652 : : inheritance, then we can't see it, unless we are a friend of
1653 : : the current binfo. */
1654 : 3915505 : if (BINFO_BASE_ACCESS (binfo, ix) != access_public_node)
1655 : : {
1656 : 1704344 : tree scope;
1657 : 1704344 : if (!friends_p)
1658 : 169 : continue;
1659 : 1704175 : scope = current_scope ();
1660 : 1731695 : if (!scope
1661 : 1704175 : || TREE_CODE (scope) == NAMESPACE_DECL
1662 : 3408242 : || !is_friend (BINFO_TYPE (binfo), scope))
1663 : 27520 : continue;
1664 : : }
1665 : :
1666 : 3887816 : if (mark)
1667 : 398 : pset->add (base_binfo);
1668 : :
1669 : 3887816 : rval = dfs_walk_once_accessible_r (base_binfo, friends_p, pset,
1670 : : pre_fn, post_fn, data);
1671 : 3887816 : if (rval)
1672 : 3322050 : return rval;
1673 : : }
1674 : :
1675 : 38014725 : skip_bases:
1676 : : /* Call the post-order walking function. */
1677 : 38014725 : if (post_fn)
1678 : : {
1679 : 38014399 : rval = post_fn (binfo, data);
1680 : 38014399 : gcc_assert (rval != dfs_skip_bases);
1681 : : return rval;
1682 : : }
1683 : :
1684 : : return NULL_TREE;
1685 : : }
1686 : :
1687 : : /* Like dfs_walk_once except that only accessible bases are walked.
1688 : : FRIENDS_P indicates whether friendship of the local context
1689 : : should be considered when determining accessibility. */
1690 : :
1691 : : static tree
1692 : 37455919 : dfs_walk_once_accessible (tree binfo, bool friends_p,
1693 : : tree (*pre_fn) (tree, void *),
1694 : : tree (*post_fn) (tree, void *), void *data)
1695 : : {
1696 : 37455919 : hash_set<tree> *pset = NULL;
1697 : 37455919 : if (CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo)))
1698 : 1921 : pset = new hash_set<tree>;
1699 : 37455919 : tree rval = dfs_walk_once_accessible_r (binfo, friends_p, pset,
1700 : : pre_fn, post_fn, data);
1701 : :
1702 : 37455919 : if (pset)
1703 : 1921 : delete pset;
1704 : 37455919 : return rval;
1705 : : }
1706 : :
1707 : : /* Return true iff the code of T is CODE, and it has compatible
1708 : : type with TYPE. */
1709 : :
1710 : : static bool
1711 : 448 : matches_code_and_type_p (tree t, enum tree_code code, tree type)
1712 : : {
1713 : 448 : if (TREE_CODE (t) != code)
1714 : : return false;
1715 : 434 : if (!cxx_types_compatible_p (TREE_TYPE (t), type))
1716 : : return false;
1717 : : return true;
1718 : : }
1719 : :
1720 : : /* Subroutine of direct_accessor_p and reference_accessor_p.
1721 : : Determine if COMPONENT_REF is a simple field lookup of this->FIELD_DECL.
1722 : : We expect a tree of the form:
1723 : : <component_ref:
1724 : : <indirect_ref:S>
1725 : : <nop_expr:P*
1726 : : <parm_decl (this)>
1727 : : <field_decl (FIELD_DECL)>>>. */
1728 : :
1729 : : static bool
1730 : 203 : field_access_p (tree component_ref, tree field_decl, tree field_type)
1731 : : {
1732 : 203 : if (!matches_code_and_type_p (component_ref, COMPONENT_REF, field_type))
1733 : : return false;
1734 : :
1735 : 189 : tree indirect_ref = TREE_OPERAND (component_ref, 0);
1736 : 189 : if (!INDIRECT_REF_P (indirect_ref))
1737 : : return false;
1738 : :
1739 : 189 : tree ptr = STRIP_NOPS (TREE_OPERAND (indirect_ref, 0));
1740 : 189 : if (!is_object_parameter (ptr))
1741 : : return false;
1742 : :
1743 : : /* Must access the correct field. */
1744 : 189 : if (TREE_OPERAND (component_ref, 1) != field_decl)
1745 : : return false;
1746 : : return true;
1747 : : }
1748 : :
1749 : : /* Subroutine of field_accessor_p.
1750 : :
1751 : : Assuming that INIT_EXPR has already had its code and type checked,
1752 : : determine if it is a simple accessor for FIELD_DECL
1753 : : (of type FIELD_TYPE).
1754 : :
1755 : : Specifically, a simple accessor within struct S of the form:
1756 : : T get_field () { return m_field; }
1757 : : should have a constexpr_fn_retval (saved_tree) of the form:
1758 : : <init_expr:T
1759 : : <result_decl:T
1760 : : <nop_expr:T
1761 : : <component_ref:
1762 : : <indirect_ref:S>
1763 : : <nop_expr:P*
1764 : : <parm_decl (this)>
1765 : : <field_decl (FIELD_DECL)>>>>>. */
1766 : :
1767 : : static bool
1768 : 161 : direct_accessor_p (tree init_expr, tree field_decl, tree field_type)
1769 : : {
1770 : 161 : tree result_decl = TREE_OPERAND (init_expr, 0);
1771 : 161 : if (!matches_code_and_type_p (result_decl, RESULT_DECL, field_type))
1772 : : return false;
1773 : :
1774 : 161 : tree component_ref = STRIP_NOPS (TREE_OPERAND (init_expr, 1));
1775 : 161 : if (!field_access_p (component_ref, field_decl, field_type))
1776 : : return false;
1777 : :
1778 : : return true;
1779 : : }
1780 : :
1781 : : /* Subroutine of field_accessor_p.
1782 : :
1783 : : Assuming that INIT_EXPR has already had its code and type checked,
1784 : : determine if it is a "reference" accessor for FIELD_DECL
1785 : : (of type FIELD_REFERENCE_TYPE).
1786 : :
1787 : : Specifically, a simple accessor within struct S of the form:
1788 : : T& get_field () { return m_field; }
1789 : : should have a constexpr_fn_retval (saved_tree) of the form:
1790 : : <init_expr:T&
1791 : : <result_decl:T&
1792 : : <nop_expr: T&
1793 : : <addr_expr: T*
1794 : : <component_ref:T
1795 : : <indirect_ref:S
1796 : : <nop_expr
1797 : : <parm_decl (this)>>
1798 : : <field (FIELD_DECL)>>>>>>. */
1799 : : static bool
1800 : 42 : reference_accessor_p (tree init_expr, tree field_decl, tree field_type,
1801 : : tree field_reference_type)
1802 : : {
1803 : 42 : tree result_decl = TREE_OPERAND (init_expr, 0);
1804 : 42 : if (!matches_code_and_type_p (result_decl, RESULT_DECL, field_reference_type))
1805 : : return false;
1806 : :
1807 : 42 : tree field_pointer_type = build_pointer_type (field_type);
1808 : 42 : tree addr_expr = STRIP_NOPS (TREE_OPERAND (init_expr, 1));
1809 : 42 : if (!matches_code_and_type_p (addr_expr, ADDR_EXPR, field_pointer_type))
1810 : : return false;
1811 : :
1812 : 42 : tree component_ref = STRIP_NOPS (TREE_OPERAND (addr_expr, 0));
1813 : :
1814 : 42 : if (!field_access_p (component_ref, field_decl, field_type))
1815 : : return false;
1816 : :
1817 : : return true;
1818 : : }
1819 : :
1820 : : /* Return the class of the `this' or explicit object parameter of FN. */
1821 : :
1822 : : static tree
1823 : 49 : class_of_object_parm (const_tree fn)
1824 : : {
1825 : 49 : tree fntype = TREE_TYPE (fn);
1826 : 49 : if (DECL_XOBJ_MEMBER_FUNCTION_P (fn))
1827 : 0 : return non_reference (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
1828 : 49 : return class_of_this_parm (fntype);
1829 : : }
1830 : :
1831 : : /* Return true if FN is an accessor method for FIELD_DECL.
1832 : : i.e. a method of the form { return FIELD; }, with no
1833 : : conversions.
1834 : :
1835 : : If CONST_P, then additionally require that FN be a const
1836 : : method. */
1837 : :
1838 : : static bool
1839 : 3031 : field_accessor_p (tree fn, tree field_decl, bool const_p)
1840 : : {
1841 : 3031 : if (TREE_CODE (fn) != FUNCTION_DECL)
1842 : : return false;
1843 : :
1844 : : /* We don't yet support looking up static data, just fields. */
1845 : 770 : if (TREE_CODE (field_decl) != FIELD_DECL)
1846 : : return false;
1847 : :
1848 : 757 : if (!DECL_OBJECT_MEMBER_FUNCTION_P (fn))
1849 : : return false;
1850 : :
1851 : : /* If the field is accessed via a const "this" argument, verify
1852 : : that the "this" parameter is const. */
1853 : 757 : if (const_p)
1854 : : {
1855 : 49 : tree this_class = class_of_object_parm (fn);
1856 : 49 : if (!TYPE_READONLY (this_class))
1857 : : return false;
1858 : : }
1859 : :
1860 : 729 : tree saved_tree = DECL_SAVED_TREE (fn);
1861 : :
1862 : 729 : if (saved_tree == NULL_TREE)
1863 : : return false;
1864 : :
1865 : : /* Attempt to extract a single return value from the function,
1866 : : if it has one. */
1867 : 228 : tree retval = constexpr_fn_retval (saved_tree);
1868 : 228 : if (retval == NULL_TREE || retval == error_mark_node)
1869 : : return false;
1870 : : /* Require an INIT_EXPR. */
1871 : 203 : if (TREE_CODE (retval) != INIT_EXPR)
1872 : : return false;
1873 : 203 : tree init_expr = retval;
1874 : :
1875 : : /* Determine if this is a simple accessor within struct S of the form:
1876 : : T get_field () { return m_field; }. */
1877 : 203 : tree field_type = TREE_TYPE (field_decl);
1878 : 203 : if (cxx_types_compatible_p (TREE_TYPE (init_expr), field_type))
1879 : 161 : return direct_accessor_p (init_expr, field_decl, field_type);
1880 : :
1881 : : /* Failing that, determine if it is an accessor of the form:
1882 : : T& get_field () { return m_field; }. */
1883 : 42 : tree field_reference_type = cp_build_reference_type (field_type, false);
1884 : 42 : if (cxx_types_compatible_p (TREE_TYPE (init_expr), field_reference_type))
1885 : 42 : return reference_accessor_p (init_expr, field_decl, field_type,
1886 : 42 : field_reference_type);
1887 : :
1888 : : return false;
1889 : : }
1890 : :
1891 : : /* Callback data for dfs_locate_field_accessor_pre. */
1892 : :
1893 : : class locate_field_data
1894 : : {
1895 : : public:
1896 : 460 : locate_field_data (tree field_decl_, bool const_p_)
1897 : 460 : : field_decl (field_decl_), const_p (const_p_) {}
1898 : :
1899 : : tree field_decl;
1900 : : bool const_p;
1901 : : };
1902 : :
1903 : : /* Return a FUNCTION_DECL that is an "accessor" method for DATA, a FIELD_DECL,
1904 : : callable via binfo, if one exists, otherwise return NULL_TREE.
1905 : :
1906 : : Callback for dfs_walk_once_accessible for use within
1907 : : locate_field_accessor. */
1908 : :
1909 : : static tree
1910 : 508 : dfs_locate_field_accessor_pre (tree binfo, void *data)
1911 : : {
1912 : 508 : locate_field_data *lfd = (locate_field_data *)data;
1913 : 508 : tree type = BINFO_TYPE (binfo);
1914 : :
1915 : 508 : vec<tree, va_gc> *member_vec;
1916 : 508 : tree fn;
1917 : 508 : size_t i;
1918 : :
1919 : 508 : if (!CLASS_TYPE_P (type))
1920 : : return NULL_TREE;
1921 : :
1922 : 508 : member_vec = CLASSTYPE_MEMBER_VEC (type);
1923 : 508 : if (!member_vec)
1924 : : return NULL_TREE;
1925 : :
1926 : 3253 : for (i = 0; vec_safe_iterate (member_vec, i, &fn); ++i)
1927 : 3031 : if (fn)
1928 : 3031 : if (field_accessor_p (fn, lfd->field_decl, lfd->const_p))
1929 : 161 : return fn;
1930 : :
1931 : : return NULL_TREE;
1932 : : }
1933 : :
1934 : : /* Return a FUNCTION_DECL that is an "accessor" method for FIELD_DECL,
1935 : : callable via BASETYPE_PATH, if one exists, otherwise return NULL_TREE. */
1936 : :
1937 : : tree
1938 : 460 : locate_field_accessor (tree basetype_path, tree field_decl, bool const_p)
1939 : : {
1940 : 460 : if (TREE_CODE (basetype_path) != TREE_BINFO)
1941 : : return NULL_TREE;
1942 : :
1943 : : /* Walk the hierarchy, looking for a method of some base class that allows
1944 : : access to the field. */
1945 : 460 : locate_field_data lfd (field_decl, const_p);
1946 : 460 : return dfs_walk_once_accessible (basetype_path, /*friends=*/true,
1947 : : dfs_locate_field_accessor_pre,
1948 : 460 : NULL, &lfd);
1949 : : }
1950 : :
1951 : : /* Check throw specifier of OVERRIDER is at least as strict as
1952 : : the one of BASEFN. This is due to [except.spec]: "If a virtual function
1953 : : has a non-throwing exception specification, all declarations, including
1954 : : the definition, of any function that overrides that virtual function in
1955 : : any derived class shall have a non-throwing exception specification,
1956 : : unless the overriding function is defined as deleted." */
1957 : :
1958 : : bool
1959 : 3216695 : maybe_check_overriding_exception_spec (tree overrider, tree basefn)
1960 : : {
1961 : 3216695 : maybe_instantiate_noexcept (basefn);
1962 : 3216695 : maybe_instantiate_noexcept (overrider);
1963 : 3216695 : tree base_throw = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (basefn));
1964 : 3216695 : tree over_throw = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (overrider));
1965 : :
1966 : 3216695 : if (DECL_INVALID_OVERRIDER_P (overrider)
1967 : : /* CWG 1351 added the "unless the overriding function is defined as
1968 : : deleted" wording. */
1969 : 3216695 : || DECL_DELETED_FN (overrider))
1970 : : return true;
1971 : :
1972 : : /* Can't check this yet. Pretend this is fine and let
1973 : : noexcept_override_late_checks check this later. */
1974 : 2106356 : if (UNPARSED_NOEXCEPT_SPEC_P (base_throw)
1975 : 7429488 : || UNPARSED_NOEXCEPT_SPEC_P (over_throw))
1976 : : return true;
1977 : :
1978 : : /* We also have to defer checking when we're in a template and couldn't
1979 : : instantiate & evaluate the noexcept to true/false. */
1980 : 3216677 : if (processing_template_decl)
1981 : 6 : if ((base_throw
1982 : 3 : && base_throw != noexcept_true_spec
1983 : 0 : && base_throw != noexcept_false_spec)
1984 : 6 : || (over_throw
1985 : 6 : && over_throw != noexcept_true_spec
1986 : 6 : && over_throw != noexcept_false_spec))
1987 : : return true;
1988 : :
1989 : 3216671 : if (!comp_except_specs (base_throw, over_throw, ce_derived))
1990 : : {
1991 : 53 : auto_diagnostic_group d;
1992 : 53 : error ("looser exception specification on overriding virtual function "
1993 : : "%q+#F", overrider);
1994 : 53 : inform (DECL_SOURCE_LOCATION (basefn),
1995 : : "overridden function is %q#F", basefn);
1996 : 53 : DECL_INVALID_OVERRIDER_P (overrider) = 1;
1997 : 53 : return false;
1998 : 53 : }
1999 : : return true;
2000 : : }
2001 : :
2002 : : /* Check that virtual overrider OVERRIDER is acceptable for base function
2003 : : BASEFN. Issue diagnostic, and return zero, if unacceptable. */
2004 : :
2005 : : static int
2006 : 3216756 : check_final_overrider (tree overrider, tree basefn)
2007 : : {
2008 : 3216756 : tree over_type = TREE_TYPE (overrider);
2009 : 3216756 : tree base_type = TREE_TYPE (basefn);
2010 : 3216756 : tree over_return = fndecl_declared_return_type (overrider);
2011 : 3216756 : tree base_return = fndecl_declared_return_type (basefn);
2012 : :
2013 : 3216756 : int fail = 0;
2014 : :
2015 : 3216756 : if (DECL_INVALID_OVERRIDER_P (overrider))
2016 : : return 0;
2017 : :
2018 : 3216746 : if (same_type_p (base_return, over_return))
2019 : : /* OK */;
2020 : 0 : else if ((CLASS_TYPE_P (over_return) && CLASS_TYPE_P (base_return))
2021 : 363 : || (TREE_CODE (base_return) == TREE_CODE (over_return)
2022 : 344 : && INDIRECT_TYPE_P (base_return)))
2023 : : {
2024 : : /* Potentially covariant. */
2025 : 344 : unsigned base_quals, over_quals;
2026 : :
2027 : 344 : fail = !INDIRECT_TYPE_P (base_return);
2028 : 344 : if (!fail)
2029 : : {
2030 : 344 : if (cp_type_quals (base_return) != cp_type_quals (over_return))
2031 : 0 : fail = 1;
2032 : :
2033 : 344 : if (TYPE_REF_P (base_return)
2034 : 344 : && (TYPE_REF_IS_RVALUE (base_return)
2035 : 78 : != TYPE_REF_IS_RVALUE (over_return)))
2036 : : fail = 1;
2037 : :
2038 : 344 : base_return = TREE_TYPE (base_return);
2039 : 344 : over_return = TREE_TYPE (over_return);
2040 : : }
2041 : 344 : base_quals = cp_type_quals (base_return);
2042 : 344 : over_quals = cp_type_quals (over_return);
2043 : :
2044 : 344 : if ((base_quals & over_quals) != over_quals)
2045 : 4 : fail = 1;
2046 : :
2047 : 344 : if (CLASS_TYPE_P (base_return) && CLASS_TYPE_P (over_return))
2048 : : {
2049 : : /* Strictly speaking, the standard requires the return type to be
2050 : : complete even if it only differs in cv-quals, but that seems
2051 : : like a bug in the wording. */
2052 : 332 : if (!same_type_ignoring_top_level_qualifiers_p (base_return,
2053 : : over_return))
2054 : : {
2055 : 321 : tree binfo = lookup_base (over_return, base_return,
2056 : : ba_check, NULL, tf_none);
2057 : :
2058 : 321 : if (!binfo || binfo == error_mark_node)
2059 : : fail = 1;
2060 : : }
2061 : : }
2062 : 12 : else if (can_convert_standard (TREE_TYPE (base_type),
2063 : 12 : TREE_TYPE (over_type),
2064 : : tf_warning_or_error))
2065 : : /* GNU extension, allow trivial pointer conversions such as
2066 : : converting to void *, or qualification conversion. */
2067 : : {
2068 : 0 : auto_diagnostic_group d;
2069 : 0 : if (pedwarn (DECL_SOURCE_LOCATION (overrider), 0,
2070 : : "invalid covariant return type for %q#D", overrider))
2071 : 0 : inform (DECL_SOURCE_LOCATION (basefn),
2072 : : "overridden function is %q#D", basefn);
2073 : 0 : }
2074 : : else
2075 : : fail = 2;
2076 : : }
2077 : : else
2078 : : fail = 2;
2079 : 312 : if (!fail)
2080 : : /* OK */;
2081 : : else
2082 : : {
2083 : 57 : auto_diagnostic_group d;
2084 : 57 : if (fail == 1)
2085 : 26 : error ("invalid covariant return type for %q+#D", overrider);
2086 : : else
2087 : 31 : error ("conflicting return type specified for %q+#D", overrider);
2088 : 57 : inform (DECL_SOURCE_LOCATION (basefn),
2089 : : "overridden function is %q#D", basefn);
2090 : 57 : DECL_INVALID_OVERRIDER_P (overrider) = 1;
2091 : 57 : return 0;
2092 : 57 : }
2093 : :
2094 : 3216689 : if (!maybe_check_overriding_exception_spec (overrider, basefn))
2095 : : return 0;
2096 : :
2097 : : /* Check for conflicting type attributes. But leave transaction_safe for
2098 : : set_one_vmethod_tm_attributes. */
2099 : 3216636 : if (!comp_type_attributes (over_type, base_type)
2100 : 72 : && !tx_safe_fn_type_p (base_type)
2101 : 3216645 : && !tx_safe_fn_type_p (over_type))
2102 : : {
2103 : 0 : auto_diagnostic_group d;
2104 : 0 : error ("conflicting type attributes specified for %q+#D", overrider);
2105 : 0 : inform (DECL_SOURCE_LOCATION (basefn),
2106 : : "overridden function is %q#D", basefn);
2107 : 0 : DECL_INVALID_OVERRIDER_P (overrider) = 1;
2108 : 0 : return 0;
2109 : 0 : }
2110 : :
2111 : : /* A consteval virtual function shall not override a virtual function that is
2112 : : not consteval. A consteval virtual function shall not be overridden by a
2113 : : virtual function that is not consteval. */
2114 : 9649908 : if (DECL_IMMEDIATE_FUNCTION_P (overrider)
2115 : 6433272 : != DECL_IMMEDIATE_FUNCTION_P (basefn))
2116 : : {
2117 : 2 : auto_diagnostic_group d;
2118 : 4 : if (DECL_IMMEDIATE_FUNCTION_P (overrider))
2119 : 1 : error ("%<consteval%> function %q+D overriding non-%<consteval%> "
2120 : : "function", overrider);
2121 : : else
2122 : 1 : error ("non-%<consteval%> function %q+D overriding %<consteval%> "
2123 : : "function", overrider);
2124 : 2 : inform (DECL_SOURCE_LOCATION (basefn),
2125 : : "overridden function is %qD", basefn);
2126 : 2 : DECL_INVALID_OVERRIDER_P (overrider) = 1;
2127 : 2 : return 0;
2128 : 2 : }
2129 : :
2130 : : /* A function declared transaction_safe_dynamic that overrides a function
2131 : : declared transaction_safe (but not transaction_safe_dynamic) is
2132 : : ill-formed. */
2133 : 3216634 : if (tx_safe_fn_type_p (base_type)
2134 : 80 : && lookup_attribute ("transaction_safe_dynamic",
2135 : 80 : DECL_ATTRIBUTES (overrider))
2136 : 3216647 : && !lookup_attribute ("transaction_safe_dynamic",
2137 : 13 : DECL_ATTRIBUTES (basefn)))
2138 : : {
2139 : 1 : auto_diagnostic_group d;
2140 : 1 : error_at (DECL_SOURCE_LOCATION (overrider),
2141 : : "%qD declared %<transaction_safe_dynamic%>", overrider);
2142 : 1 : inform (DECL_SOURCE_LOCATION (basefn),
2143 : : "overriding %qD declared %<transaction_safe%>", basefn);
2144 : 1 : }
2145 : :
2146 : 3216634 : if (DECL_DELETED_FN (basefn) != DECL_DELETED_FN (overrider))
2147 : : {
2148 : 18 : if (DECL_DELETED_FN (overrider))
2149 : : {
2150 : 15 : auto_diagnostic_group d;
2151 : 15 : error ("deleted function %q+D overriding non-deleted function",
2152 : : overrider);
2153 : 15 : inform (DECL_SOURCE_LOCATION (basefn),
2154 : : "overridden function is %qD", basefn);
2155 : 15 : maybe_explain_implicit_delete (overrider);
2156 : 15 : }
2157 : : else
2158 : : {
2159 : 3 : auto_diagnostic_group d;
2160 : 3 : error ("non-deleted function %q+D overriding deleted function",
2161 : : overrider);
2162 : 3 : inform (DECL_SOURCE_LOCATION (basefn),
2163 : : "overridden function is %qD", basefn);
2164 : 3 : }
2165 : 18 : return 0;
2166 : : }
2167 : :
2168 : 3216616 : if (!DECL_HAS_CONTRACTS_P (basefn) && DECL_HAS_CONTRACTS_P (overrider))
2169 : : {
2170 : 0 : auto_diagnostic_group d;
2171 : 0 : error ("function with contracts %q+D overriding contractless function",
2172 : : overrider);
2173 : 0 : inform (DECL_SOURCE_LOCATION (basefn),
2174 : : "overridden function is %qD", basefn);
2175 : 0 : return 0;
2176 : 0 : }
2177 : 3216616 : else if (DECL_HAS_CONTRACTS_P (basefn) && !DECL_HAS_CONTRACTS_P (overrider))
2178 : : {
2179 : : /* We're inheriting basefn's contracts; create a copy of them but
2180 : : replace references to their parms to our parms. */
2181 : 12 : inherit_base_contracts (overrider, basefn);
2182 : : }
2183 : 3216604 : else if (DECL_HAS_CONTRACTS_P (basefn) && DECL_HAS_CONTRACTS_P (overrider))
2184 : : {
2185 : : /* We're in the process of completing the overrider's class, which means
2186 : : our conditions definitely are not parsed so simply chain on the
2187 : : basefn for later checking.
2188 : :
2189 : : Note that OVERRIDER's contracts will have been fully parsed at the
2190 : : point the deferred match is run. */
2191 : 20 : defer_guarded_contract_match (overrider, basefn, DECL_CONTRACTS (basefn));
2192 : : }
2193 : :
2194 : 3216616 : if (DECL_FINAL_P (basefn))
2195 : : {
2196 : 6 : auto_diagnostic_group d;
2197 : 6 : error ("virtual function %q+D overriding final function", overrider);
2198 : 6 : inform (DECL_SOURCE_LOCATION (basefn),
2199 : : "overridden function is %qD", basefn);
2200 : 6 : return 0;
2201 : 6 : }
2202 : : return 1;
2203 : : }
2204 : :
2205 : : /* Given a class TYPE, and a function decl FNDECL, look for
2206 : : virtual functions in TYPE's hierarchy which FNDECL overrides.
2207 : : We do not look in TYPE itself, only its bases.
2208 : :
2209 : : Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
2210 : : find that it overrides anything.
2211 : :
2212 : : We check that every function which is overridden, is correctly
2213 : : overridden. */
2214 : :
2215 : : int
2216 : 13827741 : look_for_overrides (tree type, tree fndecl)
2217 : : {
2218 : 13827741 : tree binfo = TYPE_BINFO (type);
2219 : 13827741 : tree base_binfo;
2220 : 13827741 : int ix;
2221 : 13827741 : int found = 0;
2222 : :
2223 : : /* A constructor for a class T does not override a function T
2224 : : in a base class. */
2225 : 27655482 : if (DECL_CONSTRUCTOR_P (fndecl))
2226 : : return 0;
2227 : :
2228 : 21658204 : for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
2229 : : {
2230 : 7830463 : tree basetype = BINFO_TYPE (base_binfo);
2231 : :
2232 : 7830463 : if (TYPE_POLYMORPHIC_P (basetype))
2233 : 4729652 : found += look_for_overrides_r (basetype, fndecl);
2234 : : }
2235 : : return found;
2236 : : }
2237 : :
2238 : : /* Look in TYPE for virtual functions with the same signature as
2239 : : FNDECL. */
2240 : :
2241 : : tree
2242 : 22705753 : look_for_overrides_here (tree type, tree fndecl)
2243 : : {
2244 : 22705753 : tree ovl = get_class_binding (type, DECL_NAME (fndecl));
2245 : :
2246 : 23477327 : for (ovl_iterator iter (ovl); iter; ++iter)
2247 : : {
2248 : 17769502 : tree fn = *iter;
2249 : :
2250 : 17769502 : if (!DECL_VIRTUAL_P (fn))
2251 : : /* Not a virtual. */;
2252 : 17721928 : else if (DECL_CONTEXT (fn) != type)
2253 : : /* Introduced with a using declaration. */;
2254 : 17721739 : else if (DECL_STATIC_FUNCTION_P (fndecl)
2255 : 17721739 : || DECL_XOBJ_MEMBER_FUNCTION_P (fndecl))
2256 : : {
2257 : 32 : tree btypes = TYPE_ARG_TYPES (TREE_TYPE (fn));
2258 : 32 : tree dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2259 : 32 : dtypes = DECL_XOBJ_MEMBER_FUNCTION_P (fndecl) ? TREE_CHAIN (dtypes)
2260 : : : dtypes;
2261 : 32 : if (compparms (TREE_CHAIN (btypes), dtypes))
2262 : 17359318 : return fn;
2263 : : }
2264 : 17721707 : else if (same_signature_p (fndecl, fn))
2265 : 17359294 : return fn;
2266 : : }
2267 : :
2268 : 5346435 : return NULL_TREE;
2269 : : }
2270 : :
2271 : : /* Look in TYPE for virtual functions overridden by FNDECL. Check both
2272 : : TYPE itself and its bases. */
2273 : :
2274 : : static int
2275 : 4729652 : look_for_overrides_r (tree type, tree fndecl)
2276 : : {
2277 : 4729652 : tree fn = look_for_overrides_here (type, fndecl);
2278 : 4729652 : if (fn)
2279 : : {
2280 : 3216780 : if (DECL_STATIC_FUNCTION_P (fndecl))
2281 : : {
2282 : : /* A static member function cannot match an inherited
2283 : : virtual member function. */
2284 : 8 : auto_diagnostic_group d;
2285 : 8 : error ("%q+#D cannot be declared", fndecl);
2286 : 8 : error (" since %q+#D declared in base class", fn);
2287 : 8 : }
2288 : 3216772 : else if (DECL_XOBJ_MEMBER_FUNCTION_P (fndecl))
2289 : : {
2290 : 16 : auto_diagnostic_group d;
2291 : 16 : error_at (DECL_SOURCE_LOCATION (fndecl),
2292 : : "explicit object member function "
2293 : : "overrides virtual function");
2294 : 16 : inform (DECL_SOURCE_LOCATION (fn),
2295 : : "virtual function declared here");
2296 : 16 : }
2297 : : else
2298 : : {
2299 : : /* It's definitely virtual, even if not explicitly set. */
2300 : 3216756 : DECL_VIRTUAL_P (fndecl) = 1;
2301 : 3216756 : check_final_overrider (fndecl, fn);
2302 : : }
2303 : 3216780 : return 1;
2304 : : }
2305 : :
2306 : : /* We failed to find one declared in this class. Look in its bases. */
2307 : 1512872 : return look_for_overrides (type, fndecl);
2308 : : }
2309 : :
2310 : : /* Called via dfs_walk from dfs_get_pure_virtuals. */
2311 : :
2312 : : static tree
2313 : 4532387 : dfs_get_pure_virtuals (tree binfo, void *data)
2314 : : {
2315 : 4532387 : tree type = (tree) data;
2316 : :
2317 : : /* We're not interested in primary base classes; the derived class
2318 : : of which they are a primary base will contain the information we
2319 : : need. */
2320 : 4532387 : if (!BINFO_PRIMARY_P (binfo))
2321 : : {
2322 : 2206230 : tree virtuals;
2323 : :
2324 : 2206230 : for (virtuals = BINFO_VIRTUALS (binfo);
2325 : 10925750 : virtuals;
2326 : 8719520 : virtuals = TREE_CHAIN (virtuals))
2327 : 8719520 : if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals)))
2328 : 500292 : vec_safe_push (CLASSTYPE_PURE_VIRTUALS (type), BV_FN (virtuals));
2329 : : }
2330 : :
2331 : 4532387 : return NULL_TREE;
2332 : : }
2333 : :
2334 : : /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
2335 : :
2336 : : void
2337 : 1408058 : get_pure_virtuals (tree type)
2338 : : {
2339 : : /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
2340 : : is going to be overridden. */
2341 : 1408058 : CLASSTYPE_PURE_VIRTUALS (type) = NULL;
2342 : : /* Now, run through all the bases which are not primary bases, and
2343 : : collect the pure virtual functions. We look at the vtable in
2344 : : each class to determine what pure virtual functions are present.
2345 : : (A primary base is not interesting because the derived class of
2346 : : which it is a primary base will contain vtable entries for the
2347 : : pure virtuals in the base class. */
2348 : 1408058 : dfs_walk_once (TYPE_BINFO (type), NULL, dfs_get_pure_virtuals, type);
2349 : 1408058 : }
2350 : :
2351 : : /* Debug info for C++ classes can get very large; try to avoid
2352 : : emitting it everywhere.
2353 : :
2354 : : Note that this optimization wins even when the target supports
2355 : : BINCL (if only slightly), and reduces the amount of work for the
2356 : : linker. */
2357 : :
2358 : : void
2359 : 35955569 : maybe_suppress_debug_info (tree t)
2360 : : {
2361 : 35955569 : if (write_symbols == NO_DEBUG)
2362 : : return;
2363 : :
2364 : : /* We might have set this earlier in cp_finish_decl. */
2365 : 34575509 : TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 0;
2366 : :
2367 : : /* Always emit the information for each class every time. */
2368 : 34575509 : if (flag_emit_class_debug_always)
2369 : : return;
2370 : :
2371 : : /* If we already know how we're handling this class, handle debug info
2372 : : the same way. */
2373 : 34575509 : if (CLASSTYPE_INTERFACE_KNOWN (t))
2374 : : {
2375 : 1 : if (CLASSTYPE_INTERFACE_ONLY (t))
2376 : 1 : TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
2377 : : /* else don't set it. */
2378 : : }
2379 : : /* If the class has a vtable, write out the debug info along with
2380 : : the vtable. */
2381 : 34575508 : else if (TYPE_CONTAINS_VPTR_P (t))
2382 : 1510236 : TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
2383 : :
2384 : : /* Otherwise, just emit the debug info normally. */
2385 : : }
2386 : :
2387 : : /* Note that we want debugging information for a base class of a class
2388 : : whose vtable is being emitted. Normally, this would happen because
2389 : : calling the constructor for a derived class implies calling the
2390 : : constructors for all bases, which involve initializing the
2391 : : appropriate vptr with the vtable for the base class; but in the
2392 : : presence of optimization, this initialization may be optimized
2393 : : away, so we tell finish_vtable_vardecl that we want the debugging
2394 : : information anyway. */
2395 : :
2396 : : static tree
2397 : 651009 : dfs_debug_mark (tree binfo, void * /*data*/)
2398 : : {
2399 : 651009 : tree t = BINFO_TYPE (binfo);
2400 : :
2401 : 651009 : if (CLASSTYPE_DEBUG_REQUESTED (t))
2402 : : return dfs_skip_bases;
2403 : :
2404 : 406064 : CLASSTYPE_DEBUG_REQUESTED (t) = 1;
2405 : :
2406 : 406064 : return NULL_TREE;
2407 : : }
2408 : :
2409 : : /* Write out the debugging information for TYPE, whose vtable is being
2410 : : emitted. Also walk through our bases and note that we want to
2411 : : write out information for them. This avoids the problem of not
2412 : : writing any debug info for intermediate basetypes whose
2413 : : constructors, and thus the references to their vtables, and thus
2414 : : the vtables themselves, were optimized away. */
2415 : :
2416 : : void
2417 : 300243 : note_debug_info_needed (tree type)
2418 : : {
2419 : 300243 : if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
2420 : : {
2421 : 258726 : TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)) = 0;
2422 : 258726 : rest_of_type_compilation (type, namespace_bindings_p ());
2423 : : }
2424 : :
2425 : 300243 : dfs_walk_all (TYPE_BINFO (type), dfs_debug_mark, NULL, 0);
2426 : 300243 : }
2427 : :
2428 : : /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2429 : : by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2430 : : BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2431 : : bases have been encountered already in the tree walk. PARENT_CONVS
2432 : : is the list of lists of conversion functions that could hide CONV
2433 : : and OTHER_CONVS is the list of lists of conversion functions that
2434 : : could hide or be hidden by CONV, should virtualness be involved in
2435 : : the hierarchy. Merely checking the conversion op's name is not
2436 : : enough because two conversion operators to the same type can have
2437 : : different names. Return nonzero if we are visible. */
2438 : :
2439 : : static int
2440 : 15115739 : check_hidden_convs (tree binfo, int virtual_depth, int virtualness,
2441 : : tree to_type, tree parent_convs, tree other_convs)
2442 : : {
2443 : 15115739 : tree level, probe;
2444 : :
2445 : : /* See if we are hidden by a parent conversion. */
2446 : 15117489 : for (level = parent_convs; level; level = TREE_CHAIN (level))
2447 : 7717 : for (probe = TREE_VALUE (level); probe; probe = TREE_CHAIN (probe))
2448 : 5967 : if (same_type_p (to_type, TREE_TYPE (probe)))
2449 : : return 0;
2450 : :
2451 : 15111576 : if (virtual_depth || virtualness)
2452 : : {
2453 : : /* In a virtual hierarchy, we could be hidden, or could hide a
2454 : : conversion function on the other_convs list. */
2455 : 72652 : for (level = other_convs; level; level = TREE_CHAIN (level))
2456 : : {
2457 : 1258 : int we_hide_them;
2458 : 1258 : int they_hide_us;
2459 : 1258 : tree *prev, other;
2460 : :
2461 : 1258 : if (!(virtual_depth || TREE_STATIC (level)))
2462 : : /* Neither is morally virtual, so cannot hide each other. */
2463 : 0 : continue;
2464 : :
2465 : 1258 : if (!TREE_VALUE (level))
2466 : : /* They evaporated away already. */
2467 : 0 : continue;
2468 : :
2469 : 2524 : they_hide_us = (virtual_depth
2470 : 1258 : && original_binfo (binfo, TREE_PURPOSE (level)));
2471 : 8 : we_hide_them = (!they_hide_us && TREE_STATIC (level)
2472 : 8 : && original_binfo (TREE_PURPOSE (level), binfo));
2473 : :
2474 : 1258 : if (!(we_hide_them || they_hide_us))
2475 : : /* Neither is within the other, so no hiding can occur. */
2476 : 0 : continue;
2477 : :
2478 : 1266 : for (prev = &TREE_VALUE (level), other = *prev; other;)
2479 : : {
2480 : 1258 : if (same_type_p (to_type, TREE_TYPE (other)))
2481 : : {
2482 : 1258 : if (they_hide_us)
2483 : : /* We are hidden. */
2484 : : return 0;
2485 : :
2486 : 8 : if (we_hide_them)
2487 : : {
2488 : : /* We hide the other one. */
2489 : 8 : other = TREE_CHAIN (other);
2490 : 8 : *prev = other;
2491 : 8 : continue;
2492 : : }
2493 : : }
2494 : 0 : prev = &TREE_CHAIN (other);
2495 : 0 : other = *prev;
2496 : : }
2497 : : }
2498 : : }
2499 : : return 1;
2500 : : }
2501 : :
2502 : : /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2503 : : of conversion functions, the first slot will be for the current
2504 : : binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2505 : : of conversion functions from children of the current binfo,
2506 : : concatenated with conversions from elsewhere in the hierarchy --
2507 : : that list begins with OTHER_CONVS. Return a single list of lists
2508 : : containing only conversions from the current binfo and its
2509 : : children. */
2510 : :
2511 : : static tree
2512 : 14309880 : split_conversions (tree my_convs, tree parent_convs,
2513 : : tree child_convs, tree other_convs)
2514 : : {
2515 : 14309880 : tree t;
2516 : 14309880 : tree prev;
2517 : :
2518 : : /* Remove the original other_convs portion from child_convs. */
2519 : 14309880 : for (prev = NULL, t = child_convs;
2520 : 15109514 : t != other_convs; prev = t, t = TREE_CHAIN (t))
2521 : 799634 : continue;
2522 : :
2523 : 14309880 : if (prev)
2524 : 799528 : TREE_CHAIN (prev) = NULL_TREE;
2525 : : else
2526 : : child_convs = NULL_TREE;
2527 : :
2528 : : /* Attach the child convs to any we had at this level. */
2529 : 14309880 : if (my_convs)
2530 : : {
2531 : 13506703 : my_convs = parent_convs;
2532 : 13506703 : TREE_CHAIN (my_convs) = child_convs;
2533 : : }
2534 : : else
2535 : : my_convs = child_convs;
2536 : :
2537 : 14309880 : return my_convs;
2538 : 799634 : }
2539 : :
2540 : : /* Worker for lookup_conversions. Lookup conversion functions in
2541 : : BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in a
2542 : : morally virtual base, and VIRTUALNESS is nonzero, if we've
2543 : : encountered virtual bases already in the tree walk. PARENT_CONVS
2544 : : is a list of conversions within parent binfos. OTHER_CONVS are
2545 : : conversions found elsewhere in the tree. Return the conversions
2546 : : found within this portion of the graph in CONVS. Return nonzero if
2547 : : we encountered virtualness. We keep template and non-template
2548 : : conversions separate, to avoid unnecessary type comparisons.
2549 : :
2550 : : The located conversion functions are held in lists of lists. The
2551 : : TREE_VALUE of the outer list is the list of conversion functions
2552 : : found in a particular binfo. The TREE_PURPOSE of both the outer
2553 : : and inner lists is the binfo at which those conversions were
2554 : : found. TREE_STATIC is set for those lists within of morally
2555 : : virtual binfos. The TREE_VALUE of the inner list is the conversion
2556 : : function or overload itself. The TREE_TYPE of each inner list node
2557 : : is the converted-to type. */
2558 : :
2559 : : static int
2560 : 37714824 : lookup_conversions_r (tree binfo, int virtual_depth, int virtualness,
2561 : : tree parent_convs, tree other_convs, tree *convs)
2562 : : {
2563 : 37714824 : int my_virtualness = 0;
2564 : 37714824 : tree my_convs = NULL_TREE;
2565 : 37714824 : tree child_convs = NULL_TREE;
2566 : :
2567 : : /* If we have no conversion operators, then don't look. */
2568 : 37714824 : if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo)))
2569 : : {
2570 : 23404944 : *convs = NULL_TREE;
2571 : :
2572 : 23404944 : return 0;
2573 : : }
2574 : :
2575 : 14309880 : if (BINFO_VIRTUAL_P (binfo))
2576 : 72652 : virtual_depth++;
2577 : :
2578 : : /* First, locate the unhidden ones at this level. */
2579 : 14309880 : if (tree conv = get_class_binding (BINFO_TYPE (binfo), conv_op_identifier))
2580 : 30941528 : for (ovl_iterator iter (conv); iter; ++iter)
2581 : : {
2582 : 15115739 : tree fn = *iter;
2583 : 15115739 : tree type = DECL_CONV_FN_TYPE (fn);
2584 : :
2585 : 15115739 : if (TREE_CODE (fn) != TEMPLATE_DECL && type_uses_auto (type))
2586 : : {
2587 : 3 : mark_used (fn);
2588 : 3 : type = DECL_CONV_FN_TYPE (fn);
2589 : : }
2590 : :
2591 : 15115739 : if (check_hidden_convs (binfo, virtual_depth, virtualness,
2592 : : type, parent_convs, other_convs))
2593 : : {
2594 : 15110326 : my_convs = tree_cons (binfo, fn, my_convs);
2595 : 15110326 : TREE_TYPE (my_convs) = type;
2596 : 15110326 : if (virtual_depth)
2597 : : {
2598 : 71386 : TREE_STATIC (my_convs) = 1;
2599 : 71386 : my_virtualness = 1;
2600 : : }
2601 : : }
2602 : : }
2603 : :
2604 : 13510082 : if (my_convs)
2605 : : {
2606 : 13506703 : parent_convs = tree_cons (binfo, my_convs, parent_convs);
2607 : 13506703 : if (virtual_depth)
2608 : 71386 : TREE_STATIC (parent_convs) = 1;
2609 : : }
2610 : :
2611 : 14309880 : child_convs = other_convs;
2612 : :
2613 : : /* Now iterate over each base, looking for more conversions. */
2614 : 14309880 : unsigned i;
2615 : 14309880 : tree base_binfo;
2616 : 15719096 : for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2617 : : {
2618 : 1409216 : tree base_convs;
2619 : 1409216 : unsigned base_virtualness;
2620 : :
2621 : 1409216 : base_virtualness = lookup_conversions_r (base_binfo,
2622 : : virtual_depth, virtualness,
2623 : : parent_convs, child_convs,
2624 : : &base_convs);
2625 : 1409216 : if (base_virtualness)
2626 : 88902 : my_virtualness = virtualness = 1;
2627 : 1409216 : child_convs = chainon (base_convs, child_convs);
2628 : : }
2629 : :
2630 : 14309880 : *convs = split_conversions (my_convs, parent_convs,
2631 : : child_convs, other_convs);
2632 : :
2633 : 14309880 : return my_virtualness;
2634 : : }
2635 : :
2636 : : /* Return a TREE_LIST containing all the non-hidden user-defined
2637 : : conversion functions for TYPE (and its base-classes). The
2638 : : TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2639 : : function. The TREE_PURPOSE is the BINFO from which the conversion
2640 : : functions in this node were selected. This function is effectively
2641 : : performing a set of member lookups as lookup_fnfield does, but
2642 : : using the type being converted to as the unique key, rather than the
2643 : : field name. */
2644 : :
2645 : : tree
2646 : 36305789 : lookup_conversions (tree type)
2647 : : {
2648 : 36305789 : tree convs;
2649 : :
2650 : 36305789 : complete_type (type);
2651 : 36305789 : if (!CLASS_TYPE_P (type) || !TYPE_BINFO (type))
2652 : : return NULL_TREE;
2653 : :
2654 : 36305608 : lookup_conversions_r (TYPE_BINFO (type), 0, 0, NULL_TREE, NULL_TREE, &convs);
2655 : :
2656 : 36305608 : tree list = NULL_TREE;
2657 : :
2658 : : /* Flatten the list-of-lists */
2659 : 49812311 : for (; convs; convs = TREE_CHAIN (convs))
2660 : : {
2661 : 13506703 : tree probe, next;
2662 : :
2663 : 28617021 : for (probe = TREE_VALUE (convs); probe; probe = next)
2664 : : {
2665 : 15110318 : next = TREE_CHAIN (probe);
2666 : :
2667 : 15110318 : TREE_CHAIN (probe) = list;
2668 : 15110318 : list = probe;
2669 : : }
2670 : : }
2671 : :
2672 : : return list;
2673 : : }
2674 : :
2675 : : /* Returns the binfo of the first direct or indirect virtual base derived
2676 : : from BINFO, or NULL if binfo is not via virtual. */
2677 : :
2678 : : tree
2679 : 104 : binfo_from_vbase (tree binfo)
2680 : : {
2681 : 164 : for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
2682 : : {
2683 : 164 : if (BINFO_VIRTUAL_P (binfo))
2684 : 104 : return binfo;
2685 : : }
2686 : : return NULL_TREE;
2687 : : }
2688 : :
2689 : : /* Returns the binfo of the first direct or indirect virtual base derived
2690 : : from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2691 : : via virtual. */
2692 : :
2693 : : tree
2694 : 347544206 : binfo_via_virtual (tree binfo, tree limit)
2695 : : {
2696 : 347544206 : if (limit && !CLASSTYPE_VBASECLASSES (limit))
2697 : : /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2698 : : return NULL_TREE;
2699 : :
2700 : 12501868 : for (; binfo && !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), limit);
2701 : 1822005 : binfo = BINFO_INHERITANCE_CHAIN (binfo))
2702 : : {
2703 : 3700341 : if (BINFO_VIRTUAL_P (binfo))
2704 : 1878336 : return binfo;
2705 : : }
2706 : : return NULL_TREE;
2707 : : }
2708 : :
2709 : : /* BINFO is for a base class in some hierarchy. Return true iff it is a
2710 : : direct base. */
2711 : :
2712 : : bool
2713 : 44064 : binfo_direct_p (tree binfo)
2714 : : {
2715 : 44064 : tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo);
2716 : 44064 : if (BINFO_INHERITANCE_CHAIN (d_binfo))
2717 : : /* A second inheritance chain means indirect. */
2718 : : return false;
2719 : 44058 : if (!BINFO_VIRTUAL_P (binfo))
2720 : : /* Non-virtual, so only one inheritance chain means direct. */
2721 : : return true;
2722 : : /* A virtual base looks like a direct base, so we need to look through the
2723 : : direct bases to see if it's there. */
2724 : : tree b_binfo;
2725 : 27 : for (int i = 0; BINFO_BASE_ITERATE (d_binfo, i, b_binfo); ++i)
2726 : 24 : if (b_binfo == binfo)
2727 : : return true;
2728 : : return false;
2729 : : }
2730 : :
2731 : : /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2732 : : Find the equivalent binfo within whatever graph HERE is located.
2733 : : This is the inverse of original_binfo. */
2734 : :
2735 : : tree
2736 : 25793603 : copied_binfo (tree binfo, tree here)
2737 : : {
2738 : 25793603 : tree result = NULL_TREE;
2739 : :
2740 : 25793603 : if (BINFO_VIRTUAL_P (binfo))
2741 : : {
2742 : : tree t;
2743 : :
2744 : 6578357 : for (t = here; BINFO_INHERITANCE_CHAIN (t);
2745 : 3420664 : t = BINFO_INHERITANCE_CHAIN (t))
2746 : 3420664 : continue;
2747 : :
2748 : 3157693 : result = binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (t));
2749 : 3420664 : }
2750 : 22635910 : else if (BINFO_INHERITANCE_CHAIN (binfo))
2751 : : {
2752 : 11317955 : tree cbinfo;
2753 : 11317955 : tree base_binfo;
2754 : 11317955 : int ix;
2755 : :
2756 : 11317955 : cbinfo = copied_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
2757 : 22667510 : for (ix = 0; BINFO_BASE_ITERATE (cbinfo, ix, base_binfo); ix++)
2758 : 11349555 : if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), BINFO_TYPE (binfo)))
2759 : : {
2760 : : result = base_binfo;
2761 : : break;
2762 : : }
2763 : : }
2764 : : else
2765 : : {
2766 : 11317955 : gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here), BINFO_TYPE (binfo)));
2767 : : result = here;
2768 : : }
2769 : :
2770 : 25793603 : gcc_assert (result);
2771 : 25793603 : return result;
2772 : : }
2773 : :
2774 : : tree
2775 : 6146314 : binfo_for_vbase (tree base, tree t)
2776 : : {
2777 : 6146314 : unsigned ix;
2778 : 6146314 : tree binfo;
2779 : 6146314 : vec<tree, va_gc> *vbases;
2780 : :
2781 : 67429509 : for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
2782 : 67429509 : vec_safe_iterate (vbases, ix, &binfo); ix++)
2783 : 66172761 : if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), base))
2784 : 4889566 : return binfo;
2785 : : return NULL;
2786 : : }
2787 : :
2788 : : /* BINFO is some base binfo of HERE, within some other
2789 : : hierarchy. Return the equivalent binfo, but in the hierarchy
2790 : : dominated by HERE. This is the inverse of copied_binfo. If BINFO
2791 : : is not a base binfo of HERE, returns NULL_TREE. */
2792 : :
2793 : : tree
2794 : 1258 : original_binfo (tree binfo, tree here)
2795 : : {
2796 : 1258 : tree result = NULL;
2797 : :
2798 : 1258 : if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (here)))
2799 : : result = here;
2800 : 16 : else if (BINFO_VIRTUAL_P (binfo))
2801 : 16 : result = (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here))
2802 : 16 : ? binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (here))
2803 : : : NULL_TREE);
2804 : 0 : else if (BINFO_INHERITANCE_CHAIN (binfo))
2805 : : {
2806 : 0 : tree base_binfos;
2807 : :
2808 : 0 : base_binfos = original_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
2809 : 0 : if (base_binfos)
2810 : : {
2811 : : int ix;
2812 : : tree base_binfo;
2813 : :
2814 : 0 : for (ix = 0; (base_binfo = BINFO_BASE_BINFO (base_binfos, ix)); ix++)
2815 : 0 : if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
2816 : : BINFO_TYPE (binfo)))
2817 : : {
2818 : : result = base_binfo;
2819 : : break;
2820 : : }
2821 : : }
2822 : : }
2823 : :
2824 : 1258 : return result;
2825 : : }
2826 : :
2827 : : /* True iff TYPE has any dependent bases (and therefore we can't say
2828 : : definitively that another class is not a base of an instantiation of
2829 : : TYPE). */
2830 : :
2831 : : bool
2832 : 94724575 : any_dependent_bases_p (tree type)
2833 : : {
2834 : 94724575 : if (!type || !CLASS_TYPE_P (type) || !uses_template_parms (type))
2835 : 62939008 : return false;
2836 : :
2837 : : /* If we haven't set TYPE_BINFO yet, we don't know anything about the bases.
2838 : : Return false because in this situation we aren't actually looking up names
2839 : : in the scope of the class, so it doesn't matter whether it has dependent
2840 : : bases. */
2841 : 31785567 : if (!TYPE_BINFO (type))
2842 : : return false;
2843 : :
2844 : : unsigned i;
2845 : : tree base_binfo;
2846 : 33846628 : FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_BINFOS (TYPE_BINFO (type)), i, base_binfo)
2847 : 19467721 : if (BINFO_DEPENDENT_BASE_P (base_binfo))
2848 : : return true;
2849 : :
2850 : : return false;
2851 : : }
|
