|
111
|
1 /* Breadth-first and depth-first routines for
|
|
|
2 searching multiple-inheritance lattice for GNU C++.
|
|
131
|
3 Copyright (C) 1987-2018 Free Software Foundation, Inc.
|
|
111
|
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
8 GCC is free software; you can redistribute it and/or modify
|
|
|
9 it under the terms of the GNU General Public License as published by
|
|
|
10 the Free Software Foundation; either version 3, or (at your option)
|
|
|
11 any later version.
|
|
|
12
|
|
|
13 GCC is distributed in the hope that it will be useful,
|
|
|
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
16 GNU General Public License for more details.
|
|
|
17
|
|
|
18 You should have received a copy of the GNU General Public License
|
|
|
19 along with GCC; see the file COPYING3. If not see
|
|
|
20 <http://www.gnu.org/licenses/>. */
|
|
|
21
|
|
|
22 /* High-level class interface. */
|
|
|
23
|
|
|
24 #include "config.h"
|
|
|
25 #include "system.h"
|
|
|
26 #include "coretypes.h"
|
|
|
27 #include "cp-tree.h"
|
|
|
28 #include "intl.h"
|
|
|
29 #include "toplev.h"
|
|
|
30 #include "spellcheck-tree.h"
|
|
|
31 #include "stringpool.h"
|
|
|
32 #include "attribs.h"
|
|
|
33
|
|
|
34 static int is_subobject_of_p (tree, tree);
|
|
|
35 static tree dfs_lookup_base (tree, void *);
|
|
|
36 static tree dfs_dcast_hint_pre (tree, void *);
|
|
|
37 static tree dfs_dcast_hint_post (tree, void *);
|
|
|
38 static tree dfs_debug_mark (tree, void *);
|
|
|
39 static int check_hidden_convs (tree, int, int, tree, tree, tree);
|
|
|
40 static tree split_conversions (tree, tree, tree, tree);
|
|
|
41 static int lookup_conversions_r (tree, int, int, tree, tree, tree *);
|
|
|
42 static int look_for_overrides_r (tree, tree);
|
|
|
43 static tree lookup_field_r (tree, void *);
|
|
|
44 static tree dfs_accessible_post (tree, void *);
|
|
|
45 static tree dfs_walk_once_accessible (tree, bool,
|
|
|
46 tree (*pre_fn) (tree, void *),
|
|
|
47 tree (*post_fn) (tree, void *),
|
|
|
48 void *data);
|
|
|
49 static tree dfs_access_in_type (tree, void *);
|
|
|
50 static access_kind access_in_type (tree, tree);
|
|
|
51 static tree dfs_get_pure_virtuals (tree, void *);
|
|
|
52
|
|
|
53
|
|
|
54 /* Data for lookup_base and its workers. */
|
|
|
55
|
|
|
56 struct lookup_base_data_s
|
|
|
57 {
|
|
|
58 tree t; /* type being searched. */
|
|
|
59 tree base; /* The base type we're looking for. */
|
|
|
60 tree binfo; /* Found binfo. */
|
|
|
61 bool via_virtual; /* Found via a virtual path. */
|
|
|
62 bool ambiguous; /* Found multiply ambiguous */
|
|
|
63 bool repeated_base; /* Whether there are repeated bases in the
|
|
|
64 hierarchy. */
|
|
|
65 bool want_any; /* Whether we want any matching binfo. */
|
|
|
66 };
|
|
|
67
|
|
|
68 /* Worker function for lookup_base. See if we've found the desired
|
|
|
69 base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
|
|
|
70
|
|
|
71 static tree
|
|
|
72 dfs_lookup_base (tree binfo, void *data_)
|
|
|
73 {
|
|
|
74 struct lookup_base_data_s *data = (struct lookup_base_data_s *) data_;
|
|
|
75
|
|
|
76 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->base))
|
|
|
77 {
|
|
|
78 if (!data->binfo)
|
|
|
79 {
|
|
|
80 data->binfo = binfo;
|
|
|
81 data->via_virtual
|
|
|
82 = binfo_via_virtual (data->binfo, data->t) != NULL_TREE;
|
|
|
83
|
|
|
84 if (!data->repeated_base)
|
|
|
85 /* If there are no repeated bases, we can stop now. */
|
|
|
86 return binfo;
|
|
|
87
|
|
|
88 if (data->want_any && !data->via_virtual)
|
|
|
89 /* If this is a non-virtual base, then we can't do
|
|
|
90 better. */
|
|
|
91 return binfo;
|
|
|
92
|
|
|
93 return dfs_skip_bases;
|
|
|
94 }
|
|
|
95 else
|
|
|
96 {
|
|
|
97 gcc_assert (binfo != data->binfo);
|
|
|
98
|
|
|
99 /* We've found more than one matching binfo. */
|
|
|
100 if (!data->want_any)
|
|
|
101 {
|
|
|
102 /* This is immediately ambiguous. */
|
|
|
103 data->binfo = NULL_TREE;
|
|
|
104 data->ambiguous = true;
|
|
|
105 return error_mark_node;
|
|
|
106 }
|
|
|
107
|
|
|
108 /* Prefer one via a non-virtual path. */
|
|
|
109 if (!binfo_via_virtual (binfo, data->t))
|
|
|
110 {
|
|
|
111 data->binfo = binfo;
|
|
|
112 data->via_virtual = false;
|
|
|
113 return binfo;
|
|
|
114 }
|
|
|
115
|
|
|
116 /* There must be repeated bases, otherwise we'd have stopped
|
|
|
117 on the first base we found. */
|
|
|
118 return dfs_skip_bases;
|
|
|
119 }
|
|
|
120 }
|
|
|
121
|
|
|
122 return NULL_TREE;
|
|
|
123 }
|
|
|
124
|
|
|
125 /* Returns true if type BASE is accessible in T. (BASE is known to be
|
|
|
126 a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
|
|
|
127 true, consider any special access of the current scope, or access
|
|
|
128 bestowed by friendship. */
|
|
|
129
|
|
|
130 bool
|
|
|
131 accessible_base_p (tree t, tree base, bool consider_local_p)
|
|
|
132 {
|
|
|
133 tree decl;
|
|
|
134
|
|
|
135 /* [class.access.base]
|
|
|
136
|
|
|
137 A base class is said to be accessible if an invented public
|
|
|
138 member of the base class is accessible.
|
|
|
139
|
|
|
140 If BASE is a non-proper base, this condition is trivially
|
|
|
141 true. */
|
|
|
142 if (same_type_p (t, base))
|
|
|
143 return true;
|
|
|
144 /* Rather than inventing a public member, we use the implicit
|
|
|
145 public typedef created in the scope of every class. */
|
|
|
146 decl = TYPE_FIELDS (base);
|
|
|
147 while (!DECL_SELF_REFERENCE_P (decl))
|
|
|
148 decl = DECL_CHAIN (decl);
|
|
|
149 while (ANON_AGGR_TYPE_P (t))
|
|
|
150 t = TYPE_CONTEXT (t);
|
|
|
151 return accessible_p (t, decl, consider_local_p);
|
|
|
152 }
|
|
|
153
|
|
|
154 /* Lookup BASE in the hierarchy dominated by T. Do access checking as
|
|
|
155 ACCESS specifies. Return the binfo we discover. If KIND_PTR is
|
|
|
156 non-NULL, fill with information about what kind of base we
|
|
|
157 discovered.
|
|
|
158
|
|
|
159 If the base is inaccessible, or ambiguous, then error_mark_node is
|
|
|
160 returned. If the tf_error bit of COMPLAIN is not set, no error
|
|
|
161 is issued. */
|
|
|
162
|
|
|
163 tree
|
|
|
164 lookup_base (tree t, tree base, base_access access,
|
|
|
165 base_kind *kind_ptr, tsubst_flags_t complain)
|
|
|
166 {
|
|
|
167 tree binfo;
|
|
|
168 tree t_binfo;
|
|
|
169 base_kind bk;
|
|
|
170
|
|
|
171 /* "Nothing" is definitely not derived from Base. */
|
|
|
172 if (t == NULL_TREE)
|
|
|
173 {
|
|
|
174 if (kind_ptr)
|
|
|
175 *kind_ptr = bk_not_base;
|
|
|
176 return NULL_TREE;
|
|
|
177 }
|
|
|
178
|
|
|
179 if (t == error_mark_node || base == error_mark_node)
|
|
|
180 {
|
|
|
181 if (kind_ptr)
|
|
|
182 *kind_ptr = bk_not_base;
|
|
|
183 return error_mark_node;
|
|
|
184 }
|
|
|
185 gcc_assert (TYPE_P (base));
|
|
|
186
|
|
|
187 if (!TYPE_P (t))
|
|
|
188 {
|
|
|
189 t_binfo = t;
|
|
|
190 t = BINFO_TYPE (t);
|
|
|
191 }
|
|
|
192 else
|
|
|
193 {
|
|
|
194 t = complete_type (TYPE_MAIN_VARIANT (t));
|
|
131
|
195 if (dependent_type_p (t))
|
|
|
196 if (tree open = currently_open_class (t))
|
|
|
197 t = open;
|
|
111
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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. */
|
|
131
|
1123 if (dependent_type_p (type))
|
|
111
|
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:
|
|
|
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
|
|
|
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 {
|
|
131
|
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));
|
|
111
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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);
|
|
131
|
1649 if (!INDIRECT_REF_P (indirect_ref))
|
|
111
|
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; }
|
|
131
|
1670 should have a constexpr_fn_retval (saved_tree) of the form:
|
|
111
|
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)>
|
|
131
|
1678 <field_decl (FIELD_DECL)>>>>>. */
|
|
111
|
1679
|
|
|
1680 static bool
|
|
|
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; }
|
|
131
|
1702 should have a constexpr_fn_retval (saved_tree) of the form:
|
|
111
|
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
|
|
|
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
|
|
|
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 {
|
|
131
|
1758 tree this_class = class_of_this_parm (fntype);
|
|
|
1759 if (!TYPE_READONLY (this_class))
|
|
111
|
1760 return false;
|
|
|
1761 }
|
|
|
1762
|
|
|
1763 tree saved_tree = DECL_SAVED_TREE (fn);
|
|
|
1764
|
|
|
1765 if (saved_tree == NULL_TREE)
|
|
|
1766 return false;
|
|
|
1767
|
|
131
|
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)
|
|
111
|
1772 return false;
|
|
131
|
1773 /* Require an INIT_EXPR. */
|
|
|
1774 if (TREE_CODE (retval) != INIT_EXPR)
|
|
111
|
1775 return false;
|
|
131
|
1776 tree init_expr = retval;
|
|
111
|
1777
|
|
|
1778 /* Determine if this is a simple accessor within struct S of the form:
|
|
|
1779 T get_field () { return m_field; }. */
|
|
131
|
1780 tree field_type = TREE_TYPE (field_decl);
|
|
111
|
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 {
|
|
|
1798 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
|
|
|
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
|
|
|
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
|
|
|
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)
|
|
131
|
1874 && INDIRECT_TYPE_P (base_return)))
|
|
111
|
1875 {
|
|
|
1876 /* Potentially covariant. */
|
|
|
1877 unsigned base_quals, over_quals;
|
|
|
1878
|
|
131
|
1879 fail = !INDIRECT_TYPE_P (base_return);
|
|
111
|
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 {
|
|
131
|
1914 auto_diagnostic_group d;
|
|
111
|
1915 if (pedwarn (DECL_SOURCE_LOCATION (overrider), 0,
|
|
|
1916 "invalid covariant return type for %q#D", overrider))
|
|
|
1917 inform (DECL_SOURCE_LOCATION (basefn),
|
|
131
|
1918 "overridden function is %q#D", basefn);
|
|
111
|
1919 }
|
|
|
1920 else
|
|
|
1921 fail = 2;
|
|
|
1922 }
|
|
|
1923 else
|
|
|
1924 fail = 2;
|
|
|
1925 if (!fail)
|
|
|
1926 /* OK */;
|
|
|
1927 else
|
|
|
1928 {
|
|
|
1929 if (fail == 1)
|
|
|
1930 {
|
|
131
|
1931 auto_diagnostic_group d;
|
|
111
|
1932 error ("invalid covariant return type for %q+#D", overrider);
|
|
131
|
1933 inform (DECL_SOURCE_LOCATION (basefn),
|
|
|
1934 "overridden function is %q#D", basefn);
|
|
111
|
1935 }
|
|
|
1936 else
|
|
|
1937 {
|
|
131
|
1938 auto_diagnostic_group d;
|
|
111
|
1939 error ("conflicting return type specified for %q+#D", overrider);
|
|
131
|
1940 inform (DECL_SOURCE_LOCATION (basefn),
|
|
|
1941 "overridden function is %q#D", basefn);
|
|
111
|
1942 }
|
|
|
1943 DECL_INVALID_OVERRIDER_P (overrider) = 1;
|
|
|
1944 return 0;
|
|
|
1945 }
|
|
|
1946
|
|
|
1947 /* Check throw specifier is at least as strict. */
|
|
|
1948 maybe_instantiate_noexcept (basefn);
|
|
|
1949 maybe_instantiate_noexcept (overrider);
|
|
|
1950 base_throw = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (basefn));
|
|
|
1951 over_throw = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (overrider));
|
|
|
1952
|
|
|
1953 if (!comp_except_specs (base_throw, over_throw, ce_derived))
|
|
|
1954 {
|
|
131
|
1955 auto_diagnostic_group d;
|
|
111
|
1956 error ("looser throw specifier for %q+#F", overrider);
|
|
131
|
1957 inform (DECL_SOURCE_LOCATION (basefn),
|
|
|
1958 "overridden function is %q#F", basefn);
|
|
111
|
1959 DECL_INVALID_OVERRIDER_P (overrider) = 1;
|
|
|
1960 return 0;
|
|
|
1961 }
|
|
|
1962
|
|
|
1963 /* Check for conflicting type attributes. But leave transaction_safe for
|
|
|
1964 set_one_vmethod_tm_attributes. */
|
|
|
1965 if (!comp_type_attributes (over_type, base_type)
|
|
|
1966 && !tx_safe_fn_type_p (base_type)
|
|
|
1967 && !tx_safe_fn_type_p (over_type))
|
|
|
1968 {
|
|
131
|
1969 auto_diagnostic_group d;
|
|
111
|
1970 error ("conflicting type attributes specified for %q+#D", overrider);
|
|
131
|
1971 inform (DECL_SOURCE_LOCATION (basefn),
|
|
|
1972 "overridden function is %q#D", basefn);
|
|
111
|
1973 DECL_INVALID_OVERRIDER_P (overrider) = 1;
|
|
|
1974 return 0;
|
|
|
1975 }
|
|
|
1976
|
|
|
1977 /* A function declared transaction_safe_dynamic that overrides a function
|
|
|
1978 declared transaction_safe (but not transaction_safe_dynamic) is
|
|
|
1979 ill-formed. */
|
|
|
1980 if (tx_safe_fn_type_p (base_type)
|
|
|
1981 && lookup_attribute ("transaction_safe_dynamic",
|
|
|
1982 DECL_ATTRIBUTES (overrider))
|
|
|
1983 && !lookup_attribute ("transaction_safe_dynamic",
|
|
|
1984 DECL_ATTRIBUTES (basefn)))
|
|
|
1985 {
|
|
131
|
1986 auto_diagnostic_group d;
|
|
111
|
1987 error_at (DECL_SOURCE_LOCATION (overrider),
|
|
|
1988 "%qD declared %<transaction_safe_dynamic%>", overrider);
|
|
|
1989 inform (DECL_SOURCE_LOCATION (basefn),
|
|
|
1990 "overriding %qD declared %<transaction_safe%>", basefn);
|
|
|
1991 }
|
|
|
1992
|
|
|
1993 if (DECL_DELETED_FN (basefn) != DECL_DELETED_FN (overrider))
|
|
|
1994 {
|
|
|
1995 if (DECL_DELETED_FN (overrider))
|
|
|
1996 {
|
|
131
|
1997 auto_diagnostic_group d;
|
|
|
1998 error ("deleted function %q+D overriding non-deleted function",
|
|
|
1999 overrider);
|
|
|
2000 inform (DECL_SOURCE_LOCATION (basefn),
|
|
|
2001 "overridden function is %qD", basefn);
|
|
111
|
2002 maybe_explain_implicit_delete (overrider);
|
|
|
2003 }
|
|
|
2004 else
|
|
|
2005 {
|
|
131
|
2006 auto_diagnostic_group d;
|
|
|
2007 error ("non-deleted function %q+D overriding deleted function",
|
|
|
2008 overrider);
|
|
|
2009 inform (DECL_SOURCE_LOCATION (basefn),
|
|
|
2010 "overridden function is %qD", basefn);
|
|
111
|
2011 }
|
|
|
2012 return 0;
|
|
|
2013 }
|
|
|
2014 if (DECL_FINAL_P (basefn))
|
|
|
2015 {
|
|
131
|
2016 auto_diagnostic_group d;
|
|
|
2017 error ("virtual function %q+D overriding final function", overrider);
|
|
|
2018 inform (DECL_SOURCE_LOCATION (basefn),
|
|
|
2019 "overridden function is %qD", basefn);
|
|
111
|
2020 return 0;
|
|
|
2021 }
|
|
|
2022 return 1;
|
|
|
2023 }
|
|
|
2024
|
|
|
2025 /* Given a class TYPE, and a function decl FNDECL, look for
|
|
|
2026 virtual functions in TYPE's hierarchy which FNDECL overrides.
|
|
|
2027 We do not look in TYPE itself, only its bases.
|
|
|
2028
|
|
|
2029 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
|
|
|
2030 find that it overrides anything.
|
|
|
2031
|
|
|
2032 We check that every function which is overridden, is correctly
|
|
|
2033 overridden. */
|
|
|
2034
|
|
|
2035 int
|
|
|
2036 look_for_overrides (tree type, tree fndecl)
|
|
|
2037 {
|
|
|
2038 tree binfo = TYPE_BINFO (type);
|
|
|
2039 tree base_binfo;
|
|
|
2040 int ix;
|
|
|
2041 int found = 0;
|
|
|
2042
|
|
|
2043 /* A constructor for a class T does not override a function T
|
|
|
2044 in a base class. */
|
|
|
2045 if (DECL_CONSTRUCTOR_P (fndecl))
|
|
|
2046 return 0;
|
|
|
2047
|
|
|
2048 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
|
|
|
2049 {
|
|
|
2050 tree basetype = BINFO_TYPE (base_binfo);
|
|
|
2051
|
|
|
2052 if (TYPE_POLYMORPHIC_P (basetype))
|
|
|
2053 found += look_for_overrides_r (basetype, fndecl);
|
|
|
2054 }
|
|
|
2055 return found;
|
|
|
2056 }
|
|
|
2057
|
|
|
2058 /* Look in TYPE for virtual functions with the same signature as
|
|
|
2059 FNDECL. */
|
|
|
2060
|
|
|
2061 tree
|
|
|
2062 look_for_overrides_here (tree type, tree fndecl)
|
|
|
2063 {
|
|
|
2064 tree ovl = get_class_binding (type, DECL_NAME (fndecl));
|
|
|
2065
|
|
|
2066 for (ovl_iterator iter (ovl); iter; ++iter)
|
|
|
2067 {
|
|
|
2068 tree fn = *iter;
|
|
|
2069
|
|
|
2070 if (!DECL_VIRTUAL_P (fn))
|
|
|
2071 /* Not a virtual. */;
|
|
|
2072 else if (DECL_CONTEXT (fn) != type)
|
|
|
2073 /* Introduced with a using declaration. */;
|
|
|
2074 else if (DECL_STATIC_FUNCTION_P (fndecl))
|
|
|
2075 {
|
|
|
2076 tree btypes = TYPE_ARG_TYPES (TREE_TYPE (fn));
|
|
|
2077 tree dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
|
|
|
2078 if (compparms (TREE_CHAIN (btypes), dtypes))
|
|
|
2079 return fn;
|
|
|
2080 }
|
|
|
2081 else if (same_signature_p (fndecl, fn))
|
|
|
2082 return fn;
|
|
|
2083 }
|
|
|
2084
|
|
|
2085 return NULL_TREE;
|
|
|
2086 }
|
|
|
2087
|
|
|
2088 /* Look in TYPE for virtual functions overridden by FNDECL. Check both
|
|
|
2089 TYPE itself and its bases. */
|
|
|
2090
|
|
|
2091 static int
|
|
|
2092 look_for_overrides_r (tree type, tree fndecl)
|
|
|
2093 {
|
|
|
2094 tree fn = look_for_overrides_here (type, fndecl);
|
|
|
2095 if (fn)
|
|
|
2096 {
|
|
|
2097 if (DECL_STATIC_FUNCTION_P (fndecl))
|
|
|
2098 {
|
|
|
2099 /* A static member function cannot match an inherited
|
|
|
2100 virtual member function. */
|
|
131
|
2101 auto_diagnostic_group d;
|
|
111
|
2102 error ("%q+#D cannot be declared", fndecl);
|
|
|
2103 error (" since %q+#D declared in base class", fn);
|
|
|
2104 }
|
|
|
2105 else
|
|
|
2106 {
|
|
|
2107 /* It's definitely virtual, even if not explicitly set. */
|
|
|
2108 DECL_VIRTUAL_P (fndecl) = 1;
|
|
|
2109 check_final_overrider (fndecl, fn);
|
|
|
2110 }
|
|
|
2111 return 1;
|
|
|
2112 }
|
|
|
2113
|
|
|
2114 /* We failed to find one declared in this class. Look in its bases. */
|
|
|
2115 return look_for_overrides (type, fndecl);
|
|
|
2116 }
|
|
|
2117
|
|
|
2118 /* Called via dfs_walk from dfs_get_pure_virtuals. */
|
|
|
2119
|
|
|
2120 static tree
|
|
|
2121 dfs_get_pure_virtuals (tree binfo, void *data)
|
|
|
2122 {
|
|
|
2123 tree type = (tree) data;
|
|
|
2124
|
|
|
2125 /* We're not interested in primary base classes; the derived class
|
|
|
2126 of which they are a primary base will contain the information we
|
|
|
2127 need. */
|
|
|
2128 if (!BINFO_PRIMARY_P (binfo))
|
|
|
2129 {
|
|
|
2130 tree virtuals;
|
|
|
2131
|
|
|
2132 for (virtuals = BINFO_VIRTUALS (binfo);
|
|
|
2133 virtuals;
|
|
|
2134 virtuals = TREE_CHAIN (virtuals))
|
|
|
2135 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals)))
|
|
|
2136 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (type), BV_FN (virtuals));
|
|
|
2137 }
|
|
|
2138
|
|
|
2139 return NULL_TREE;
|
|
|
2140 }
|
|
|
2141
|
|
|
2142 /* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
|
|
|
2143
|
|
|
2144 void
|
|
|
2145 get_pure_virtuals (tree type)
|
|
|
2146 {
|
|
|
2147 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
|
|
|
2148 is going to be overridden. */
|
|
|
2149 CLASSTYPE_PURE_VIRTUALS (type) = NULL;
|
|
|
2150 /* Now, run through all the bases which are not primary bases, and
|
|
|
2151 collect the pure virtual functions. We look at the vtable in
|
|
|
2152 each class to determine what pure virtual functions are present.
|
|
|
2153 (A primary base is not interesting because the derived class of
|
|
|
2154 which it is a primary base will contain vtable entries for the
|
|
|
2155 pure virtuals in the base class. */
|
|
|
2156 dfs_walk_once (TYPE_BINFO (type), NULL, dfs_get_pure_virtuals, type);
|
|
|
2157 }
|
|
|
2158
|
|
|
2159 /* Debug info for C++ classes can get very large; try to avoid
|
|
|
2160 emitting it everywhere.
|
|
|
2161
|
|
|
2162 Note that this optimization wins even when the target supports
|
|
|
2163 BINCL (if only slightly), and reduces the amount of work for the
|
|
|
2164 linker. */
|
|
|
2165
|
|
|
2166 void
|
|
|
2167 maybe_suppress_debug_info (tree t)
|
|
|
2168 {
|
|
|
2169 if (write_symbols == NO_DEBUG)
|
|
|
2170 return;
|
|
|
2171
|
|
|
2172 /* We might have set this earlier in cp_finish_decl. */
|
|
|
2173 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 0;
|
|
|
2174
|
|
|
2175 /* Always emit the information for each class every time. */
|
|
|
2176 if (flag_emit_class_debug_always)
|
|
|
2177 return;
|
|
|
2178
|
|
|
2179 /* If we already know how we're handling this class, handle debug info
|
|
|
2180 the same way. */
|
|
|
2181 if (CLASSTYPE_INTERFACE_KNOWN (t))
|
|
|
2182 {
|
|
|
2183 if (CLASSTYPE_INTERFACE_ONLY (t))
|
|
|
2184 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
|
|
|
2185 /* else don't set it. */
|
|
|
2186 }
|
|
|
2187 /* If the class has a vtable, write out the debug info along with
|
|
|
2188 the vtable. */
|
|
|
2189 else if (TYPE_CONTAINS_VPTR_P (t))
|
|
|
2190 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
|
|
|
2191
|
|
|
2192 /* Otherwise, just emit the debug info normally. */
|
|
|
2193 }
|
|
|
2194
|
|
|
2195 /* Note that we want debugging information for a base class of a class
|
|
|
2196 whose vtable is being emitted. Normally, this would happen because
|
|
|
2197 calling the constructor for a derived class implies calling the
|
|
|
2198 constructors for all bases, which involve initializing the
|
|
|
2199 appropriate vptr with the vtable for the base class; but in the
|
|
|
2200 presence of optimization, this initialization may be optimized
|
|
|
2201 away, so we tell finish_vtable_vardecl that we want the debugging
|
|
|
2202 information anyway. */
|
|
|
2203
|
|
|
2204 static tree
|
|
|
2205 dfs_debug_mark (tree binfo, void * /*data*/)
|
|
|
2206 {
|
|
|
2207 tree t = BINFO_TYPE (binfo);
|
|
|
2208
|
|
|
2209 if (CLASSTYPE_DEBUG_REQUESTED (t))
|
|
|
2210 return dfs_skip_bases;
|
|
|
2211
|
|
|
2212 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
|
|
|
2213
|
|
|
2214 return NULL_TREE;
|
|
|
2215 }
|
|
|
2216
|
|
|
2217 /* Write out the debugging information for TYPE, whose vtable is being
|
|
|
2218 emitted. Also walk through our bases and note that we want to
|
|
|
2219 write out information for them. This avoids the problem of not
|
|
|
2220 writing any debug info for intermediate basetypes whose
|
|
|
2221 constructors, and thus the references to their vtables, and thus
|
|
|
2222 the vtables themselves, were optimized away. */
|
|
|
2223
|
|
|
2224 void
|
|
|
2225 note_debug_info_needed (tree type)
|
|
|
2226 {
|
|
|
2227 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
|
|
|
2228 {
|
|
|
2229 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)) = 0;
|
|
|
2230 rest_of_type_compilation (type, namespace_bindings_p ());
|
|
|
2231 }
|
|
|
2232
|
|
|
2233 dfs_walk_all (TYPE_BINFO (type), dfs_debug_mark, NULL, 0);
|
|
|
2234 }
|
|
|
2235
|
|
|
2236 /* Helper for lookup_conversions_r. TO_TYPE is the type converted to
|
|
|
2237 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
|
|
|
2238 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
|
|
|
2239 bases have been encountered already in the tree walk. PARENT_CONVS
|
|
|
2240 is the list of lists of conversion functions that could hide CONV
|
|
|
2241 and OTHER_CONVS is the list of lists of conversion functions that
|
|
|
2242 could hide or be hidden by CONV, should virtualness be involved in
|
|
|
2243 the hierarchy. Merely checking the conversion op's name is not
|
|
|
2244 enough because two conversion operators to the same type can have
|
|
|
2245 different names. Return nonzero if we are visible. */
|
|
|
2246
|
|
|
2247 static int
|
|
|
2248 check_hidden_convs (tree binfo, int virtual_depth, int virtualness,
|
|
|
2249 tree to_type, tree parent_convs, tree other_convs)
|
|
|
2250 {
|
|
|
2251 tree level, probe;
|
|
|
2252
|
|
|
2253 /* See if we are hidden by a parent conversion. */
|
|
|
2254 for (level = parent_convs; level; level = TREE_CHAIN (level))
|
|
|
2255 for (probe = TREE_VALUE (level); probe; probe = TREE_CHAIN (probe))
|
|
|
2256 if (same_type_p (to_type, TREE_TYPE (probe)))
|
|
|
2257 return 0;
|
|
|
2258
|
|
|
2259 if (virtual_depth || virtualness)
|
|
|
2260 {
|
|
|
2261 /* In a virtual hierarchy, we could be hidden, or could hide a
|
|
|
2262 conversion function on the other_convs list. */
|
|
|
2263 for (level = other_convs; level; level = TREE_CHAIN (level))
|
|
|
2264 {
|
|
|
2265 int we_hide_them;
|
|
|
2266 int they_hide_us;
|
|
|
2267 tree *prev, other;
|
|
|
2268
|
|
|
2269 if (!(virtual_depth || TREE_STATIC (level)))
|
|
|
2270 /* Neither is morally virtual, so cannot hide each other. */
|
|
|
2271 continue;
|
|
|
2272
|
|
|
2273 if (!TREE_VALUE (level))
|
|
|
2274 /* They evaporated away already. */
|
|
|
2275 continue;
|
|
|
2276
|
|
|
2277 they_hide_us = (virtual_depth
|
|
|
2278 && original_binfo (binfo, TREE_PURPOSE (level)));
|
|
|
2279 we_hide_them = (!they_hide_us && TREE_STATIC (level)
|
|
|
2280 && original_binfo (TREE_PURPOSE (level), binfo));
|
|
|
2281
|
|
|
2282 if (!(we_hide_them || they_hide_us))
|
|
|
2283 /* Neither is within the other, so no hiding can occur. */
|
|
|
2284 continue;
|
|
|
2285
|
|
|
2286 for (prev = &TREE_VALUE (level), other = *prev; other;)
|
|
|
2287 {
|
|
|
2288 if (same_type_p (to_type, TREE_TYPE (other)))
|
|
|
2289 {
|
|
|
2290 if (they_hide_us)
|
|
|
2291 /* We are hidden. */
|
|
|
2292 return 0;
|
|
|
2293
|
|
|
2294 if (we_hide_them)
|
|
|
2295 {
|
|
|
2296 /* We hide the other one. */
|
|
|
2297 other = TREE_CHAIN (other);
|
|
|
2298 *prev = other;
|
|
|
2299 continue;
|
|
|
2300 }
|
|
|
2301 }
|
|
|
2302 prev = &TREE_CHAIN (other);
|
|
|
2303 other = *prev;
|
|
|
2304 }
|
|
|
2305 }
|
|
|
2306 }
|
|
|
2307 return 1;
|
|
|
2308 }
|
|
|
2309
|
|
|
2310 /* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
|
|
|
2311 of conversion functions, the first slot will be for the current
|
|
|
2312 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
|
|
|
2313 of conversion functions from children of the current binfo,
|
|
|
2314 concatenated with conversions from elsewhere in the hierarchy --
|
|
|
2315 that list begins with OTHER_CONVS. Return a single list of lists
|
|
|
2316 containing only conversions from the current binfo and its
|
|
|
2317 children. */
|
|
|
2318
|
|
|
2319 static tree
|
|
|
2320 split_conversions (tree my_convs, tree parent_convs,
|
|
|
2321 tree child_convs, tree other_convs)
|
|
|
2322 {
|
|
|
2323 tree t;
|
|
|
2324 tree prev;
|
|
|
2325
|
|
|
2326 /* Remove the original other_convs portion from child_convs. */
|
|
|
2327 for (prev = NULL, t = child_convs;
|
|
|
2328 t != other_convs; prev = t, t = TREE_CHAIN (t))
|
|
|
2329 continue;
|
|
|
2330
|
|
|
2331 if (prev)
|
|
|
2332 TREE_CHAIN (prev) = NULL_TREE;
|
|
|
2333 else
|
|
|
2334 child_convs = NULL_TREE;
|
|
|
2335
|
|
|
2336 /* Attach the child convs to any we had at this level. */
|
|
|
2337 if (my_convs)
|
|
|
2338 {
|
|
|
2339 my_convs = parent_convs;
|
|
|
2340 TREE_CHAIN (my_convs) = child_convs;
|
|
|
2341 }
|
|
|
2342 else
|
|
|
2343 my_convs = child_convs;
|
|
|
2344
|
|
|
2345 return my_convs;
|
|
|
2346 }
|
|
|
2347
|
|
|
2348 /* Worker for lookup_conversions. Lookup conversion functions in
|
|
|
2349 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in a
|
|
|
2350 morally virtual base, and VIRTUALNESS is nonzero, if we've
|
|
|
2351 encountered virtual bases already in the tree walk. PARENT_CONVS
|
|
|
2352 is a list of conversions within parent binfos. OTHER_CONVS are
|
|
|
2353 conversions found elsewhere in the tree. Return the conversions
|
|
|
2354 found within this portion of the graph in CONVS. Return nonzero if
|
|
|
2355 we encountered virtualness. We keep template and non-template
|
|
|
2356 conversions separate, to avoid unnecessary type comparisons.
|
|
|
2357
|
|
|
2358 The located conversion functions are held in lists of lists. The
|
|
|
2359 TREE_VALUE of the outer list is the list of conversion functions
|
|
|
2360 found in a particular binfo. The TREE_PURPOSE of both the outer
|
|
|
2361 and inner lists is the binfo at which those conversions were
|
|
|
2362 found. TREE_STATIC is set for those lists within of morally
|
|
|
2363 virtual binfos. The TREE_VALUE of the inner list is the conversion
|
|
|
2364 function or overload itself. The TREE_TYPE of each inner list node
|
|
|
2365 is the converted-to type. */
|
|
|
2366
|
|
|
2367 static int
|
|
|
2368 lookup_conversions_r (tree binfo, int virtual_depth, int virtualness,
|
|
|
2369 tree parent_convs, tree other_convs, tree *convs)
|
|
|
2370 {
|
|
|
2371 int my_virtualness = 0;
|
|
|
2372 tree my_convs = NULL_TREE;
|
|
|
2373 tree child_convs = NULL_TREE;
|
|
|
2374
|
|
|
2375 /* If we have no conversion operators, then don't look. */
|
|
|
2376 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo)))
|
|
|
2377 {
|
|
|
2378 *convs = NULL_TREE;
|
|
|
2379
|
|
|
2380 return 0;
|
|
|
2381 }
|
|
|
2382
|
|
|
2383 if (BINFO_VIRTUAL_P (binfo))
|
|
|
2384 virtual_depth++;
|
|
|
2385
|
|
|
2386 /* First, locate the unhidden ones at this level. */
|
|
|
2387 if (tree conv = get_class_binding (BINFO_TYPE (binfo), conv_op_identifier))
|
|
|
2388 for (ovl_iterator iter (conv); iter; ++iter)
|
|
|
2389 {
|
|
|
2390 tree fn = *iter;
|
|
|
2391 tree type = DECL_CONV_FN_TYPE (fn);
|
|
|
2392
|
|
|
2393 if (TREE_CODE (fn) != TEMPLATE_DECL && type_uses_auto (type))
|
|
|
2394 {
|
|
|
2395 mark_used (fn);
|
|
|
2396 type = DECL_CONV_FN_TYPE (fn);
|
|
|
2397 }
|
|
|
2398
|
|
|
2399 if (check_hidden_convs (binfo, virtual_depth, virtualness,
|
|
|
2400 type, parent_convs, other_convs))
|
|
|
2401 {
|
|
|
2402 my_convs = tree_cons (binfo, fn, my_convs);
|
|
|
2403 TREE_TYPE (my_convs) = type;
|
|
|
2404 if (virtual_depth)
|
|
|
2405 {
|
|
|
2406 TREE_STATIC (my_convs) = 1;
|
|
|
2407 my_virtualness = 1;
|
|
|
2408 }
|
|
|
2409 }
|
|
|
2410 }
|
|
|
2411
|
|
|
2412 if (my_convs)
|
|
|
2413 {
|
|
|
2414 parent_convs = tree_cons (binfo, my_convs, parent_convs);
|
|
|
2415 if (virtual_depth)
|
|
|
2416 TREE_STATIC (parent_convs) = 1;
|
|
|
2417 }
|
|
|
2418
|
|
|
2419 child_convs = other_convs;
|
|
|
2420
|
|
|
2421 /* Now iterate over each base, looking for more conversions. */
|
|
|
2422 unsigned i;
|
|
|
2423 tree base_binfo;
|
|
|
2424 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
|
|
|
2425 {
|
|
|
2426 tree base_convs;
|
|
|
2427 unsigned base_virtualness;
|
|
|
2428
|
|
|
2429 base_virtualness = lookup_conversions_r (base_binfo,
|
|
|
2430 virtual_depth, virtualness,
|
|
|
2431 parent_convs, child_convs,
|
|
|
2432 &base_convs);
|
|
|
2433 if (base_virtualness)
|
|
|
2434 my_virtualness = virtualness = 1;
|
|
|
2435 child_convs = chainon (base_convs, child_convs);
|
|
|
2436 }
|
|
|
2437
|
|
|
2438 *convs = split_conversions (my_convs, parent_convs,
|
|
|
2439 child_convs, other_convs);
|
|
|
2440
|
|
|
2441 return my_virtualness;
|
|
|
2442 }
|
|
|
2443
|
|
|
2444 /* Return a TREE_LIST containing all the non-hidden user-defined
|
|
|
2445 conversion functions for TYPE (and its base-classes). The
|
|
|
2446 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
|
|
|
2447 function. The TREE_PURPOSE is the BINFO from which the conversion
|
|
|
2448 functions in this node were selected. This function is effectively
|
|
|
2449 performing a set of member lookups as lookup_fnfield does, but
|
|
|
2450 using the type being converted to as the unique key, rather than the
|
|
|
2451 field name. */
|
|
|
2452
|
|
|
2453 tree
|
|
|
2454 lookup_conversions (tree type)
|
|
|
2455 {
|
|
|
2456 tree convs;
|
|
|
2457
|
|
|
2458 complete_type (type);
|
|
|
2459 if (!CLASS_TYPE_P (type) || !TYPE_BINFO (type))
|
|
|
2460 return NULL_TREE;
|
|
|
2461
|
|
|
2462 lookup_conversions_r (TYPE_BINFO (type), 0, 0, NULL_TREE, NULL_TREE, &convs);
|
|
|
2463
|
|
|
2464 tree list = NULL_TREE;
|
|
|
2465
|
|
|
2466 /* Flatten the list-of-lists */
|
|
|
2467 for (; convs; convs = TREE_CHAIN (convs))
|
|
|
2468 {
|
|
|
2469 tree probe, next;
|
|
|
2470
|
|
|
2471 for (probe = TREE_VALUE (convs); probe; probe = next)
|
|
|
2472 {
|
|
|
2473 next = TREE_CHAIN (probe);
|
|
|
2474
|
|
|
2475 TREE_CHAIN (probe) = list;
|
|
|
2476 list = probe;
|
|
|
2477 }
|
|
|
2478 }
|
|
|
2479
|
|
|
2480 return list;
|
|
|
2481 }
|
|
|
2482
|
|
|
2483 /* Returns the binfo of the first direct or indirect virtual base derived
|
|
|
2484 from BINFO, or NULL if binfo is not via virtual. */
|
|
|
2485
|
|
|
2486 tree
|
|
|
2487 binfo_from_vbase (tree binfo)
|
|
|
2488 {
|
|
|
2489 for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo))
|
|
|
2490 {
|
|
|
2491 if (BINFO_VIRTUAL_P (binfo))
|
|
|
2492 return binfo;
|
|
|
2493 }
|
|
|
2494 return NULL_TREE;
|
|
|
2495 }
|
|
|
2496
|
|
|
2497 /* Returns the binfo of the first direct or indirect virtual base derived
|
|
|
2498 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
|
|
|
2499 via virtual. */
|
|
|
2500
|
|
|
2501 tree
|
|
|
2502 binfo_via_virtual (tree binfo, tree limit)
|
|
|
2503 {
|
|
|
2504 if (limit && !CLASSTYPE_VBASECLASSES (limit))
|
|
|
2505 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
|
|
|
2506 return NULL_TREE;
|
|
|
2507
|
|
|
2508 for (; binfo && !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), limit);
|
|
|
2509 binfo = BINFO_INHERITANCE_CHAIN (binfo))
|
|
|
2510 {
|
|
|
2511 if (BINFO_VIRTUAL_P (binfo))
|
|
|
2512 return binfo;
|
|
|
2513 }
|
|
|
2514 return NULL_TREE;
|
|
|
2515 }
|
|
|
2516
|
|
|
2517 /* BINFO is for a base class in some hierarchy. Return true iff it is a
|
|
|
2518 direct base. */
|
|
|
2519
|
|
|
2520 bool
|
|
|
2521 binfo_direct_p (tree binfo)
|
|
|
2522 {
|
|
|
2523 tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo);
|
|
|
2524 if (BINFO_INHERITANCE_CHAIN (d_binfo))
|
|
|
2525 /* A second inheritance chain means indirect. */
|
|
|
2526 return false;
|
|
|
2527 if (!BINFO_VIRTUAL_P (binfo))
|
|
|
2528 /* Non-virtual, so only one inheritance chain means direct. */
|
|
|
2529 return true;
|
|
|
2530 /* A virtual base looks like a direct base, so we need to look through the
|
|
|
2531 direct bases to see if it's there. */
|
|
|
2532 tree b_binfo;
|
|
|
2533 for (int i = 0; BINFO_BASE_ITERATE (d_binfo, i, b_binfo); ++i)
|
|
|
2534 if (b_binfo == binfo)
|
|
|
2535 return true;
|
|
|
2536 return false;
|
|
|
2537 }
|
|
|
2538
|
|
|
2539 /* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
|
|
|
2540 Find the equivalent binfo within whatever graph HERE is located.
|
|
|
2541 This is the inverse of original_binfo. */
|
|
|
2542
|
|
|
2543 tree
|
|
|
2544 copied_binfo (tree binfo, tree here)
|
|
|
2545 {
|
|
|
2546 tree result = NULL_TREE;
|
|
|
2547
|
|
|
2548 if (BINFO_VIRTUAL_P (binfo))
|
|
|
2549 {
|
|
|
2550 tree t;
|
|
|
2551
|
|
|
2552 for (t = here; BINFO_INHERITANCE_CHAIN (t);
|
|
|
2553 t = BINFO_INHERITANCE_CHAIN (t))
|
|
|
2554 continue;
|
|
|
2555
|
|
|
2556 result = binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (t));
|
|
|
2557 }
|
|
|
2558 else if (BINFO_INHERITANCE_CHAIN (binfo))
|
|
|
2559 {
|
|
|
2560 tree cbinfo;
|
|
|
2561 tree base_binfo;
|
|
|
2562 int ix;
|
|
|
2563
|
|
|
2564 cbinfo = copied_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
|
|
|
2565 for (ix = 0; BINFO_BASE_ITERATE (cbinfo, ix, base_binfo); ix++)
|
|
|
2566 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), BINFO_TYPE (binfo)))
|
|
|
2567 {
|
|
|
2568 result = base_binfo;
|
|
|
2569 break;
|
|
|
2570 }
|
|
|
2571 }
|
|
|
2572 else
|
|
|
2573 {
|
|
|
2574 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here), BINFO_TYPE (binfo)));
|
|
|
2575 result = here;
|
|
|
2576 }
|
|
|
2577
|
|
|
2578 gcc_assert (result);
|
|
|
2579 return result;
|
|
|
2580 }
|
|
|
2581
|
|
|
2582 tree
|
|
|
2583 binfo_for_vbase (tree base, tree t)
|
|
|
2584 {
|
|
|
2585 unsigned ix;
|
|
|
2586 tree binfo;
|
|
|
2587 vec<tree, va_gc> *vbases;
|
|
|
2588
|
|
|
2589 for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
|
|
|
2590 vec_safe_iterate (vbases, ix, &binfo); ix++)
|
|
|
2591 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), base))
|
|
|
2592 return binfo;
|
|
|
2593 return NULL;
|
|
|
2594 }
|
|
|
2595
|
|
|
2596 /* BINFO is some base binfo of HERE, within some other
|
|
|
2597 hierarchy. Return the equivalent binfo, but in the hierarchy
|
|
|
2598 dominated by HERE. This is the inverse of copied_binfo. If BINFO
|
|
|
2599 is not a base binfo of HERE, returns NULL_TREE. */
|
|
|
2600
|
|
|
2601 tree
|
|
|
2602 original_binfo (tree binfo, tree here)
|
|
|
2603 {
|
|
|
2604 tree result = NULL;
|
|
|
2605
|
|
|
2606 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (here)))
|
|
|
2607 result = here;
|
|
|
2608 else if (BINFO_VIRTUAL_P (binfo))
|
|
|
2609 result = (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here))
|
|
|
2610 ? binfo_for_vbase (BINFO_TYPE (binfo), BINFO_TYPE (here))
|
|
|
2611 : NULL_TREE);
|
|
|
2612 else if (BINFO_INHERITANCE_CHAIN (binfo))
|
|
|
2613 {
|
|
|
2614 tree base_binfos;
|
|
|
2615
|
|
|
2616 base_binfos = original_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
|
|
|
2617 if (base_binfos)
|
|
|
2618 {
|
|
|
2619 int ix;
|
|
|
2620 tree base_binfo;
|
|
|
2621
|
|
|
2622 for (ix = 0; (base_binfo = BINFO_BASE_BINFO (base_binfos, ix)); ix++)
|
|
|
2623 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
|
|
|
2624 BINFO_TYPE (binfo)))
|
|
|
2625 {
|
|
|
2626 result = base_binfo;
|
|
|
2627 break;
|
|
|
2628 }
|
|
|
2629 }
|
|
|
2630 }
|
|
|
2631
|
|
|
2632 return result;
|
|
|
2633 }
|
|
|
2634
|
|
|
2635 /* True iff TYPE has any dependent bases (and therefore we can't say
|
|
|
2636 definitively that another class is not a base of an instantiation of
|
|
|
2637 TYPE). */
|
|
|
2638
|
|
|
2639 bool
|
|
|
2640 any_dependent_bases_p (tree type)
|
|
|
2641 {
|
|
131
|
2642 if (!type || !CLASS_TYPE_P (type) || !uses_template_parms (type))
|
|
|
2643 return false;
|
|
|
2644
|
|
|
2645 /* If we haven't set TYPE_BINFO yet, we don't know anything about the bases.
|
|
|
2646 Return false because in this situation we aren't actually looking up names
|
|
|
2647 in the scope of the class, so it doesn't matter whether it has dependent
|
|
|
2648 bases. */
|
|
|
2649 if (!TYPE_BINFO (type))
|
|
111
|
2650 return false;
|
|
|
2651
|
|
|
2652 unsigned i;
|
|
|
2653 tree base_binfo;
|
|
|
2654 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_BINFOS (TYPE_BINFO (type)), i, base_binfo)
|
|
|
2655 if (BINFO_DEPENDENT_BASE_P (base_binfo))
|
|
|
2656 return true;
|
|
|
2657
|
|
|
2658 return false;
|
|
|
2659 }
|
