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