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