Mercurial > hg > CbC > CbC_gcc

comparison gcc/cp/search.c @ 111:04ced10e8804

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