![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-search.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cp-search.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Breadth-first and depth-first routines for
2: searching multiple-inheritance lattice for GNU C++.
3: Copyright (C) 1987, 1989, 1992, 1993 Free Software Foundation, Inc.
4: Contributed by Michael Tiemann ([email protected])
5:
6: This file is part of GNU CC.
7:
8: GNU CC 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 2, or (at your option)
11: any later version.
12:
13: GNU CC 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 GNU CC; see the file COPYING. If not, write to
20: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21:
22: /* High-level class interface. */
23:
24: #include "config.h"
25: #include "tree.h"
26: #include <stdio.h>
27: #include "cp-tree.h"
28: #include "obstack.h"
29: #include "flags.h"
30:
31: #define obstack_chunk_alloc xmalloc
32: #define obstack_chunk_free free
33:
34: void init_search ();
35: extern struct obstack *current_obstack;
36:
37: #include "stack.h"
38:
39: /* Obstack used for remembering decision points of breadth-first. */
40: static struct obstack search_obstack;
41:
42: /* Methods for pushing and popping objects to and from obstacks. */
43: struct stack_level *
44: push_stack_level (obstack, tp, size)
45: struct obstack *obstack;
46: char *tp; /* Sony NewsOS 5.0 compiler doesn't like void * here. */
47: int size;
48: {
49: struct stack_level *stack;
50: obstack_grow (obstack, tp, size);
51: stack = (struct stack_level *) ((char*)obstack_next_free (obstack) - size);
52: obstack_finish (obstack);
53: stack->obstack = obstack;
54: stack->first = (tree *) obstack_base (obstack);
55: stack->limit = obstack_room (obstack) / sizeof (tree *);
56: return stack;
57: }
58:
59: struct stack_level *
60: pop_stack_level (stack)
61: struct stack_level *stack;
62: {
63: struct stack_level *tem = stack;
64: struct obstack *obstack = tem->obstack;
65: stack = tem->prev;
66: obstack_free (obstack, tem);
67: return stack;
68: }
69:
70: #define search_level stack_level
71: static struct search_level *search_stack;
72:
73: static tree lookup_field_1 ();
74: static int lookup_fnfields_1 ();
75: static void dfs_walk ();
76: static int markedp ();
77: static void dfs_unmark ();
78: static void dfs_init_vbase_pointers ();
79:
80: static tree vbase_types;
81: static tree vbase_decl, vbase_decl_ptr;
82: static tree vbase_decl_ptr_intermediate;
83: static tree vbase_init_result;
84:
85: /* Allocate a level of searching. */
86: static struct search_level *
87: push_search_level (stack, obstack)
88: struct stack_level *stack;
89: struct obstack *obstack;
90: {
91: struct search_level tem;
92:
93: tem.prev = stack;
94: return push_stack_level (obstack, (char *)&tem, sizeof (tem));
95: }
96:
97: /* Discard a level of search allocation. */
98: static struct search_level *
99: pop_search_level (obstack)
100: struct stack_level *obstack;
101: {
102: register struct search_level *stack = pop_stack_level (obstack);
103:
104: return stack;
105: }
106:
107: /* Search memoization. */
108: struct type_level
109: {
110: struct stack_level base;
111:
112: /* First object allocated in obstack of entries. */
113: char *entries;
114:
115: /* Number of types memoized in this context. */
116: int len;
117:
118: /* Type being memoized; save this if we are saving
119: memoized contexts. */
120: tree type;
121: };
122:
123: /* Obstack used for memoizing member and member function lookup. */
124:
125: static struct obstack type_obstack, type_obstack_entries;
126: static struct type_level *type_stack;
127: static tree _vptr_name;
128:
129: /* Make things that look like tree nodes, but allocate them
130: on type_obstack_entries. */
131: static int my_tree_node_counter;
132: static tree my_tree_cons (), my_build_string ();
133:
134: extern int flag_memoize_lookups, flag_save_memoized_contexts;
135:
136: /* Variables for gathering statistics. */
137: static int my_memoized_entry_counter;
138: static int memoized_fast_finds[2], memoized_adds[2], memoized_fast_rejects[2];
139: static int memoized_fields_searched[2];
140: static int n_fields_searched;
141: static int n_calls_lookup_field, n_calls_lookup_field_1;
142: static int n_calls_lookup_fnfields, n_calls_lookup_fnfields_1;
143: static int n_calls_get_base_type;
144: static int n_outer_fields_searched;
145: static int n_contexts_saved;
146:
147: /* Local variables to help save memoization contexts. */
148: static tree prev_type_memoized;
149: static struct type_level *prev_type_stack;
150:
151: #if NEW_CLASS_SCOPING
152: /* This list is used by push_class_decls to know what decls need to
153: be pushed into class scope. */
154: static tree closed_envelopes = NULL_TREE;
155: #endif
156:
157: /* Allocate a level of type memoization context. */
158: static struct type_level *
159: push_type_level (stack, obstack)
160: struct stack_level *stack;
161: struct obstack *obstack;
162: {
163: struct type_level tem;
164:
165: tem.base.prev = stack;
166:
167: obstack_finish (&type_obstack_entries);
168: tem.entries = (char *) obstack_base (&type_obstack_entries);
169: tem.len = 0;
170: tem.type = NULL_TREE;
171:
172: return (struct type_level *)push_stack_level (obstack, (char *)&tem, sizeof (tem));
173: }
174:
175: /* Discard a level of type memoization context. */
176:
177: static struct type_level *
178: pop_type_level (stack)
179: struct type_level *stack;
180: {
181: obstack_free (&type_obstack_entries, stack->entries);
182: return (struct type_level *)pop_stack_level ((struct stack_level *)stack);
183: }
184:
185: /* Make something that looks like a TREE_LIST, but
186: do it on the type_obstack_entries obstack. */
187: static tree
188: my_tree_cons (purpose, value, chain)
189: tree purpose, value, chain;
190: {
191: tree p = (tree)obstack_alloc (&type_obstack_entries, sizeof (struct tree_list));
192: ++my_tree_node_counter;
193: TREE_TYPE (p) = NULL_TREE;
194: ((HOST_WIDE_INT *)p)[3] = 0;
195: TREE_SET_CODE (p, TREE_LIST);
196: TREE_PURPOSE (p) = purpose;
197: TREE_VALUE (p) = value;
198: TREE_CHAIN (p) = chain;
199: return p;
200: }
201:
202: static tree
203: my_build_string (str)
204: char *str;
205: {
206: tree p = (tree)obstack_alloc (&type_obstack_entries, sizeof (struct tree_string));
207: ++my_tree_node_counter;
208: TREE_TYPE (p) = 0;
209: ((int *)p)[3] = 0;
210: TREE_SET_CODE (p, STRING_CST);
211: TREE_STRING_POINTER (p) = str;
212: TREE_STRING_LENGTH (p) = strlen (str);
213: return p;
214: }
215:
216: /* Memoizing machinery to make searches for multiple inheritance
217: reasonably efficient. */
218: #define MEMOIZE_HASHSIZE 8
219: typedef struct memoized_entry
220: {
221: struct memoized_entry *chain;
222: int uid;
223: tree data_members[MEMOIZE_HASHSIZE];
224: tree function_members[MEMOIZE_HASHSIZE];
225: } *ME;
226:
227: #define MEMOIZED_CHAIN(ENTRY) (((ME)ENTRY)->chain)
228: #define MEMOIZED_UID(ENTRY) (((ME)ENTRY)->uid)
229: #define MEMOIZED_FIELDS(ENTRY,INDEX) (((ME)ENTRY)->data_members[INDEX])
230: #define MEMOIZED_FNFIELDS(ENTRY,INDEX) (((ME)ENTRY)->function_members[INDEX])
231: /* The following is probably a lousy hash function. */
232: #define MEMOIZED_HASH_FN(NODE) (((long)(NODE)>>4)&(MEMOIZE_HASHSIZE - 1))
233:
234: static struct memoized_entry *
235: my_new_memoized_entry (chain)
236: struct memoized_entry *chain;
237: {
238: struct memoized_entry *p =
239: (struct memoized_entry *)obstack_alloc (&type_obstack_entries,
240: sizeof (struct memoized_entry));
241: bzero (p, sizeof (struct memoized_entry));
242: MEMOIZED_CHAIN (p) = chain;
243: MEMOIZED_UID (p) = ++my_memoized_entry_counter;
244: return p;
245: }
246:
247: /* Make an entry in the memoized table for type TYPE
248: that the entry for NAME is FIELD. */
249:
250: tree
251: make_memoized_table_entry (type, name, function_p)
252: tree type, name;
253: int function_p;
254: {
255: int index = MEMOIZED_HASH_FN (name);
256: tree entry, *prev_entry;
257:
258: memoized_adds[function_p] += 1;
259: if (CLASSTYPE_MTABLE_ENTRY (type) == 0)
260: {
261: obstack_ptr_grow (&type_obstack, type);
262: obstack_blank (&type_obstack, sizeof (struct memoized_entry *));
263: CLASSTYPE_MTABLE_ENTRY (type) = (char *)my_new_memoized_entry ((struct memoized_entry *)0);
264: type_stack->len++;
265: if (type_stack->len * 2 >= type_stack->base.limit)
266: my_friendly_abort (88);
267: }
268: if (function_p)
269: prev_entry = &MEMOIZED_FNFIELDS (CLASSTYPE_MTABLE_ENTRY (type), index);
270: else
271: prev_entry = &MEMOIZED_FIELDS (CLASSTYPE_MTABLE_ENTRY (type), index);
272:
273: entry = my_tree_cons (name, NULL_TREE, *prev_entry);
274: *prev_entry = entry;
275:
276: /* Don't know the error message to give yet. */
277: TREE_TYPE (entry) = error_mark_node;
278:
279: return entry;
280: }
281:
282: /* When a new function or class context is entered, we build
283: a table of types which have been searched for members.
284: The table is an array (obstack) of types. When a type is
285: entered into the obstack, its CLASSTYPE_MTABLE_ENTRY
286: field is set to point to a new record, of type struct memoized_entry.
287:
288: A non-NULL TREE_TYPE of the entry contains a visibility error message.
289:
290: The slots for the data members are arrays of tree nodes.
291: These tree nodes are lists, with the TREE_PURPOSE
292: of this list the known member name, and the TREE_VALUE
293: as the FIELD_DECL for the member.
294:
295: For member functions, the TREE_PURPOSE is again the
296: name of the member functions for that class,
297: and the TREE_VALUE of the list is a pairs
298: whose TREE_PURPOSE is a member functions of this name,
299: and whose TREE_VALUE is a list of known argument lists this
300: member function has been called with. The TREE_TYPE of the pair,
301: if non-NULL, is an error message to print. */
302:
303: /* Tell search machinery that we are entering a new context, and
304: to update tables appropriately.
305:
306: TYPE is the type of the context we are entering, which can
307: be NULL_TREE if we are not in a class's scope.
308:
309: USE_OLD, if nonzero tries to use previous context. */
310: void
311: push_memoized_context (type, use_old)
312: tree type;
313: int use_old;
314: {
315: int len;
316: tree *tem;
317:
318: if (prev_type_stack)
319: {
320: if (use_old && prev_type_memoized == type)
321: {
322: #ifdef GATHER_STATISTICS
323: n_contexts_saved++;
324: #endif
325: type_stack = prev_type_stack;
326: prev_type_stack = 0;
327:
328: tem = &type_stack->base.first[0];
329: len = type_stack->len;
330: while (len--)
331: CLASSTYPE_MTABLE_ENTRY (tem[len*2]) = (char *)tem[len*2+1];
332: return;
333: }
334: /* Otherwise, need to pop old stack here. */
335: type_stack = pop_type_level (prev_type_stack);
336: prev_type_memoized = 0;
337: prev_type_stack = 0;
338: }
339:
340: type_stack = push_type_level ((struct stack_level *)type_stack,
341: &type_obstack);
342: type_stack->type = type;
343: }
344:
345: /* Tell search machinery that we have left a context.
346: We do not currently save these contexts for later use.
347: If we wanted to, we could not use pop_search_level, since
348: poping that level allows the data we have collected to
349: be clobbered; a stack of obstacks would be needed. */
350: void
351: pop_memoized_context (use_old)
352: int use_old;
353: {
354: int len;
355: tree *tem = &type_stack->base.first[0];
356:
357: if (! flag_save_memoized_contexts)
358: use_old = 0;
359: else if (use_old)
360: {
361: len = type_stack->len;
362: while (len--)
363: tem[len*2+1] = (tree)CLASSTYPE_MTABLE_ENTRY (tem[len*2]);
364:
365: prev_type_stack = type_stack;
366: prev_type_memoized = type_stack->type;
367: }
368:
369: if (flag_memoize_lookups)
370: {
371: len = type_stack->len;
372: while (len--)
373: CLASSTYPE_MTABLE_ENTRY (tem[len*2])
374: = (char *)MEMOIZED_CHAIN (CLASSTYPE_MTABLE_ENTRY (tem[len*2]));
375: }
376: if (! use_old)
377: type_stack = pop_type_level (type_stack);
378: else
379: type_stack = (struct type_level *)type_stack->base.prev;
380: }
381:
382: /* This is the newer recursive depth first search routine. */
383: static tree
384: get_binfo_recursive (binfo, is_private, parent, rval, rval_private_ptr, xtype,
385: friends, protect)
386: tree binfo, parent, rval, xtype, friends;
387: int *rval_private_ptr, protect, is_private;
388: {
389: tree binfos;
390: int i, n_baselinks;
391:
392: if (BINFO_TYPE (binfo) == parent)
393: {
394: if (rval == NULL_TREE)
395: {
396: rval = binfo;
397: *rval_private_ptr = is_private;
398: }
399: else
400: {
401: /* I believe it is the case that this error is only an error
402: when used by someone that wants error messages printed.
403: Routines that call this one, that don't set protect want
404: the first one found, even if there are more. */
405: if (protect)
406: {
407: /* Found two or more possible return values. */
408: cp_error ("type `%T' is ambiguous base class for type `%T'",
409: parent, xtype);
410: rval = error_mark_node;
411: }
412: }
413: return rval;
414: }
415:
416: binfos = BINFO_BASETYPES (binfo);
417: n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
418:
419: /* Process base types. */
420: for (i = 0; i < n_baselinks; i++)
421: {
422: tree base_binfo = TREE_VEC_ELT (binfos, i);
423:
424: if (BINFO_MARKED (base_binfo) == 0)
425: {
426: int via_private = is_private || !TREE_VIA_PUBLIC (base_binfo);
427:
428: SET_BINFO_MARKED (base_binfo);
429:
430: if (via_private == 0)
431: ;
432: else if (protect == 0)
433: via_private = 0;
434: else if (protect == 1 && BINFO_TYPE (binfo) == current_class_type)
435: /* The immediate base class of the class we are in
436: does let its public members through. */
437: via_private = 0;
438: #ifndef NOJJG
439: else if (protect
440: && friends != NULL_TREE
441: && BINFO_TYPE (binfo) == xtype
442: && value_member (current_class_type, friends))
443: /* Friend types of the most derived type have access
444: to its baseclass pointers. */
445: via_private = 0;
446: #endif
447:
448: rval = get_binfo_recursive (base_binfo, via_private, parent, rval,
449: rval_private_ptr, xtype, friends,
450: protect);
451: if (rval == error_mark_node)
452: return rval;
453: }
454: }
455:
456: return rval;
457: }
458:
459: /* Return non-zero if PARENT is directly derived from TYPE. By directly
460: we mean it's only one step up the inheritance lattice. We check this
461: by walking horizontally across the types that TYPE directly inherits
462: from, to see if PARENT is among them. This is used by get_binfo and
463: by compute_visibility. */
464: static int
465: immediately_derived (parent, type)
466: tree parent, type;
467: {
468: if (TYPE_BINFO (type))
469: {
470: tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
471: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
472:
473: for (i = 0; i < n_baselinks; i++)
474: {
475: tree base_binfo = TREE_VEC_ELT (binfos, i);
476:
477: if (parent == BINFO_TYPE (base_binfo))
478: return 1;
479: }
480: }
481: return 0;
482: }
483:
484: /* Check whether the type given in BINFO is derived from PARENT. If
485: it isn't, return 0. If it is, but the derivation is MI-ambiguous
486: AND protect != 0, emit an error message and return error_mark_node.
487:
488: Otherwise, if TYPE is derived from PARENT, return the actual base
489: information, unless a one of the protection violations below
490: occurs, in which case emit an error message and return error_mark_node.
491:
492: The below should be worded better. It may not be exactly what the code
493: does, but there should be a lose correlation. If you understand the code
494: well, please try and make the comments below more readable.
495:
496: If PROTECT is 1, then check if access to a public field of PARENT
497: would be private.
498:
499: If PROTECT is 2, then check if the given type is derived from
500: PARENT via private visibility rules.
501:
502: If PROTECT is 3, then immediately private baseclass is ok,
503: but deeper than that, check if private. */
504: tree
505: get_binfo (parent, binfo, protect)
506: register tree parent, binfo;
507: int protect;
508: {
509: tree xtype, type;
510: tree otype;
511: int head = 0, tail = 0;
512: int is_private = 0;
513: tree rval = NULL_TREE;
514: int rval_private = 0;
515: tree friends;
516:
517: #ifdef GATHER_STATISTICS
518: n_calls_get_base_type++;
519: #endif
520:
521: if (TREE_CODE (parent) == TREE_VEC)
522: parent = BINFO_TYPE (parent);
523: /* unions cannot participate in inheritance relationships */
524: else if (TREE_CODE (parent) == UNION_TYPE)
525: return NULL_TREE;
526: else if (TREE_CODE (parent) != RECORD_TYPE)
527: my_friendly_abort (89);
528:
529: parent = TYPE_MAIN_VARIANT (parent);
530:
531: if (TREE_CODE (binfo) == TREE_VEC)
532: type = BINFO_TYPE (binfo);
533: else if (TREE_CODE (binfo) == RECORD_TYPE)
534: {
535: type = binfo;
536: binfo = TYPE_BINFO (type);
537: }
538: else my_friendly_abort (90);
539: xtype = type;
540: friends = current_class_type ? CLASSTYPE_FRIEND_CLASSES (type) : NULL_TREE;
541:
542: rval = get_binfo_recursive (binfo, is_private, parent, rval, &rval_private,
543: xtype, friends, protect);
544:
545: dfs_walk (binfo, dfs_unmark, markedp);
546:
547: if (rval && protect && rval_private)
548: {
549: if (protect == 3 && immediately_derived (parent, xtype))
550: return rval;
551: cp_error ("type `%T' is derived from private `%T'", xtype, parent);
552: return error_mark_node;
553: }
554:
555: #ifdef OBJCPLUS
556: if (!rval)
557: {
558: if (objc_comptypes (parent, type, 1) == 1)
559: return parent;
560: }
561: #endif
562:
563: return rval;
564: }
565:
566: /* This is the newer depth first get_base_distance routine. */
567: static
568: get_base_distance_recursive (binfo, depth, is_private, basetype_path, rval,
569: rval_private_ptr, new_binfo_ptr, parent, path_ptr,
570: protect, via_virtual_ptr, via_virtual)
571: tree binfo, basetype_path, *new_binfo_ptr, parent, *path_ptr;
572: int *rval_private_ptr, depth, is_private, rval, protect, *via_virtual_ptr,
573: via_virtual;
574: {
575: tree binfos;
576: int i, n_baselinks;
577:
578: if (BINFO_TYPE (binfo) == parent || binfo == parent)
579: {
580: if (rval == -1)
581: {
582: rval = depth;
583: *rval_private_ptr = is_private;
584: *new_binfo_ptr = binfo;
585: *via_virtual_ptr = via_virtual;
586: }
587: else
588: {
589: int same_object = tree_int_cst_equal (BINFO_OFFSET (*new_binfo_ptr),
590: BINFO_OFFSET (binfo));
591:
592: if (*via_virtual_ptr && via_virtual==0)
593: {
594: *rval_private_ptr = is_private;
595: *new_binfo_ptr = binfo;
596: *via_virtual_ptr = via_virtual;
597: }
598: else if (same_object)
599: {
600: /* Note, this should probably succeed to find, and
601: override the old one if the old one was private and
602: this one isn't. */
603: return rval;
604: }
605:
606: rval = -2;
607: }
608: return rval;
609: }
610:
611: binfos = BINFO_BASETYPES (binfo);
612: n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
613: depth += 1;
614:
615: /* Process base types. */
616: for (i = 0; i < n_baselinks; i++)
617: {
618: tree base_binfo = TREE_VEC_ELT (binfos, i);
619:
620: if (BINFO_MARKED (base_binfo) == 0)
621: {
622: int via_private = is_private || !TREE_VIA_PUBLIC (base_binfo);
623: int was;
624:
625: /* When searching for a non-virtual, we cannot mark
626: virtually found binfos. */
627: if (!via_virtual)
628: SET_BINFO_MARKED (base_binfo);
629:
630: if (via_private == 0)
631: ;
632: else if (protect == 0)
633: via_private = 0;
634:
635: #define WATCH_VALUES(rval, via_private) (rval == -1 ? 3 : via_private)
636:
637: was = WATCH_VALUES (rval, *via_virtual_ptr);
638: rval = get_base_distance_recursive (base_binfo, depth, via_private,
639: binfo, rval, rval_private_ptr,
640: new_binfo_ptr, parent, path_ptr,
641: protect, via_virtual_ptr,
642: TREE_VIA_VIRTUAL (base_binfo)|via_virtual);
643: /* watch for updates, only update, if path is good. */
644: if (path_ptr && WATCH_VALUES (rval, *via_virtual_ptr) != was)
645: BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
646: if (rval == -2 && *via_virtual_ptr == 0)
647: return rval;
648:
649: #undef WATCH_VALUES
650:
651: }
652: }
653:
654: return rval;
655: }
656:
657: /* Return the number of levels between type PARENT and the type given
658: in BINFO, following the leftmost path to PARENT not found along a
659: virtual path, if there are no real PARENTs (all come from virtual
660: base classes), then follow the leftmost path to PARENT.
661:
662: Return -1 if TYPE is not derived from PARENT.
663: Return -2 if PARENT is an ambiguous base class of TYPE.
664: Return -3 if PARENT is private to TYPE, and protect is non-zero.
665:
666: If PATH_PTR is non-NULL, then also build the list of types
667: from PARENT to TYPE, with TREE_VIA_VIRUAL and TREE_VIA_PUBLIC
668: set.
669:
670: PARENT can also be a binfo, in which case that exact parent is found
671: and no other. convert_pointer_to_real uses this functionality.
672:
673: Code in prepare_fresh_vtable relies upon the path being built even
674: when -2 is returned. */
675:
676: int
677: get_base_distance (parent, binfo, protect, path_ptr)
678: register tree parent, binfo;
679: int protect;
680: tree *path_ptr;
681: {
682: int head, tail;
683: int is_private = 0;
684: int rval;
685: int depth = 0;
686: int rval_private = 0;
687: tree type, basetype_path = NULL_TREE;
688: tree friends;
689: tree new_binfo = NULL_TREE;
690: int via_virtual;
691:
692: if (TREE_CODE (parent) != TREE_VEC)
693: parent = TYPE_MAIN_VARIANT (parent);
694:
695: if (TREE_CODE (binfo) == TREE_VEC)
696: type = BINFO_TYPE (binfo);
697: else if (TREE_CODE (binfo) == RECORD_TYPE)
698: {
699: type = binfo;
700: binfo = TYPE_BINFO (type);
701: }
702: else
703: my_friendly_abort (92);
704:
705: friends = current_class_type ? CLASSTYPE_FRIEND_CLASSES (type) : NULL_TREE;
706:
707: if (path_ptr)
708: {
709: basetype_path = TYPE_BINFO (type);
710: BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
711: }
712:
713: if (parent == type || parent == basetype_path)
714: {
715: /* If the distance is 0, then we don't really need
716: a path pointer, but we shouldn't let garbage go back. */
717: if (path_ptr)
718: *path_ptr = basetype_path;
719: return 0;
720: }
721:
722: rval = get_base_distance_recursive (binfo, 0, 0, NULL_TREE, -1,
723: &rval_private, &new_binfo, parent,
724: path_ptr, protect, &via_virtual, 0);
725:
726: if (path_ptr)
727: BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
728:
729: basetype_path = binfo;
730:
731: dfs_walk (binfo, dfs_unmark, markedp);
732:
733: binfo = new_binfo;
734:
735: /* Visibilities don't count if we found an ambiguous basetype. */
736: if (rval == -2)
737: rval_private = 0;
738:
739: if (rval && protect && rval_private)
740: return -3;
741:
742: if (path_ptr)
743: *path_ptr = binfo;
744: return rval;
745: }
746:
747: /* Search for a member with name NAME in a multiple inheritance lattice
748: specified by TYPE. If it does not exist, return NULL_TREE.
749: If the member is ambiguously referenced, return `error_mark_node'.
750: Otherwise, return the FIELD_DECL. */
751:
752: /* Do a 1-level search for NAME as a member of TYPE. The caller
753: must figure out whether it has a visible path to this field.
754: (Since it is only one level, this is reasonable.) */
755: static tree
756: lookup_field_1 (type, name)
757: tree type, name;
758: {
759: register tree field = TYPE_FIELDS (type);
760:
761: #ifdef GATHER_STATISTICS
762: n_calls_lookup_field_1++;
763: #endif
764: while (field)
765: {
766: #ifdef GATHER_STATISTICS
767: n_fields_searched++;
768: #endif
769: if (DECL_NAME (field) == NULL_TREE
770: && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
771: {
772: tree temp = lookup_field_1 (TREE_TYPE (field), name);
773: if (temp)
774: return temp;
775: }
776: if (DECL_NAME (field) == name)
777: {
778: if ((TREE_CODE(field) == VAR_DECL || TREE_CODE(field) == CONST_DECL)
779: && DECL_ASSEMBLER_NAME (field) != NULL)
780: GNU_xref_ref(current_function_decl,
781: IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (field)));
782: return field;
783: }
784: field = TREE_CHAIN (field);
785: }
786: /* Not found. */
787: if (name == _vptr_name)
788: {
789: /* Give the user what s/he thinks s/he wants. */
790: if (TYPE_VIRTUAL_P (type))
791: return CLASSTYPE_VFIELD (type);
792: }
793: return NULL_TREE;
794: }
795:
796: /* Compute the visibility of FIELD. This is done by computing
797: the visibility available to each type in BASETYPES (which comes
798: as a list of [via_public/basetype] in reverse order, namely base
799: class before derived class). The first one which defines a
800: visibility defines the visibility for the field. Otherwise, the
801: visibility of the field is that which occurs normally.
802:
803: Uses global variables CURRENT_CLASS_TYPE and
804: CURRENT_FUNCTION_DECL to use friend relationships
805: if necessary.
806:
807: This will be static when lookup_fnfield comes into this file. */
808:
809: #define PUBLIC_RETURN return (DECL_PUBLIC (field) = 1), visibility_public
810: #define PROTECTED_RETURN return (DECL_PROTECTED (field) = 1), visibility_protected
811: #define PRIVATE_RETURN return (DECL_PRIVATE (field) = 1), visibility_private
812:
813: enum visibility_type
814: compute_visibility (basetype_path, field)
815: tree basetype_path, field;
816: {
817: enum visibility_type visibility = visibility_public;
818: tree types;
819: tree context = DECL_CLASS_CONTEXT (field);
820: /* Used once we go past an access gate that makes private really
821: deny us access from the context. */
822: int really_private;
823:
824: if (context == NULL_TREE)
825: context = DECL_CONTEXT (field);
826:
827: /* Fields coming from nested anonymous unions have their DECL_CLASS_CONTEXT
828: slot set to the union type rather than the record type containing
829: the anonymous union. In this case, DECL_FIELD_CONTEXT is correct. */
830: if (context && TREE_CODE (context) == UNION_TYPE
831: && ANON_AGGRNAME_P (TYPE_IDENTIFIER (context)))
832: context = DECL_FIELD_CONTEXT (field);
833:
834: /* Virtual function tables are never private. But we should know that
835: we are looking for this, and not even try to hide it. */
836: if (DECL_NAME (field) && VFIELD_NAME_P (DECL_NAME (field)) == 1)
837: return visibility_public;
838:
839: /* Member function manipulating its own members. */
840: if (current_class_type == context
841: || (context && current_class_type == TYPE_MAIN_VARIANT (context)))
842: PUBLIC_RETURN;
843:
844: /* Make these special cases fast. */
845: if (BINFO_TYPE (basetype_path) == current_class_type)
846: {
847: if (DECL_PUBLIC (field))
848: return visibility_public;
849: if (DECL_PROTECTED (field))
850: return visibility_protected;
851: if (DECL_PRIVATE (field))
852: return visibility_private;
853: }
854:
855: /* Member found immediately within object. */
856: if (BINFO_INHERITANCE_CHAIN (basetype_path) == NULL_TREE)
857: {
858: /* At the object's top level, public members are public. */
859: if (!TREE_PROTECTED (field) && !TREE_PRIVATE (field))
860: PUBLIC_RETURN;
861:
862: /* Is it a friend function manipulating members that it gets by
863: virtue of its friendship? Or are we friends with the class
864: that has FIELD? */
865: if ((current_function_decl && is_friend (context, current_function_decl))
866: || (is_friend_type (context, current_class_type)))
867: PUBLIC_RETURN;
868:
869: if (current_class_type && DECL_VISIBILITY (field) == NULL_TREE)
870: {
871: /* If it's private, it's private, you letch. */
872: if (TREE_PRIVATE (field))
873: PRIVATE_RETURN;
874:
875: /* ARM $11.5. Member functions of a derived class can access the
876: non-static protected members of a base class only through a
877: pointer to the derived class, a reference to it, or an object
878: of it. Also any subsequently derived classes also have
879: access. */
880: if (TREE_PROTECTED (field))
881: {
882: if (context == current_class_type
883: || UNIQUELY_DERIVED_FROM_P (context, current_class_type))
884: PUBLIC_RETURN;
885: else
886: PROTECTED_RETURN;
887: }
888: else
889: /* Will we ever actually reach here? Doubt it. */
890: my_friendly_abort (94);
891: }
892: }
893:
894: /* Is it a friend function manipulating members that it gets by
895: virtue of its friendship? */
896: if (is_friend (context, current_function_decl))
897: PUBLIC_RETURN;
898:
899: /* must reverse more than one element */
900: basetype_path = reverse_path (basetype_path);
901: types = basetype_path;
902: really_private = 0;
903:
904: while (types)
905: {
906: tree member;
907: tree binfo = types;
908: tree type = BINFO_TYPE (binfo);
909:
910: member = purpose_member (type, DECL_VISIBILITY (field));
911: if (member)
912: {
913: visibility = (enum visibility_type)TREE_VALUE (member);
914: if (visibility == visibility_public
915: || is_friend (type, current_function_decl)
916: || (visibility == visibility_protected
917: && current_class_type
918: && UNIQUELY_DERIVED_FROM_P (context, current_class_type)))
919: visibility = visibility_public;
920: goto ret;
921: }
922:
923: /* Friends inherit the visibility of the class they inherit from. */
924: if (is_friend (type, current_function_decl))
925: {
926: if (type == context)
927: {
928: visibility = visibility_public;
929: goto ret;
930: }
931: if (TREE_PROTECTED (field))
932: {
933: visibility = visibility_public;
934: goto ret;
935: }
936: /* else, may be a friend of a deeper base class */
937: }
938:
939: if (type == context)
940: break;
941:
942: types = BINFO_INHERITANCE_CHAIN (types);
943:
944: /* If the next type was not VIA_PUBLIC, then fields of all
945: remaining class past that one are private. */
946: if (types)
947: {
948: if (TREE_VIA_PROTECTED (types))
949: {
950: if (really_private == 0)
951: really_private = 1;
952: else
953: visibility = visibility_protected;
954: }
955: else if (! TREE_VIA_PUBLIC (types))
956: {
957: if (really_private == 0)
958: really_private = 2;
959: else
960: visibility = visibility_private;
961: }
962: }
963: }
964:
965: /* No special visibilities apply. Use normal rules.
966: No assignment needed for BASETYPEs here from the nreverse.
967: This is because we use it only for information about the
968: path to the base. The code earlier dealt with what
969: happens when we are at the base level. */
970:
971: if (visibility == visibility_public)
972: {
973: reverse_path (basetype_path);
974: if (TREE_PRIVATE (field))
975: PRIVATE_RETURN;
976: if (TREE_PROTECTED (field))
977: {
978: /* Used to check if the current class type was derived from
979: the type that contains the field. This is wrong for
980: multiple inheritance because is gives one class reference
981: to protected members via another classes protected path.
982: I.e., if A; B1 : A; B2 : A; Then B1 and B2 can access
983: their own members which are protected in A, but not
984: those same members in one another. */
985: if (current_class_type
986: && UNIQUELY_DERIVED_FROM_P (context, current_class_type))
987: PUBLIC_RETURN;
988: PROTECTED_RETURN;
989: }
990: PUBLIC_RETURN;
991: }
992:
993: if (visibility == visibility_protected)
994: {
995: reverse_path (basetype_path);
996:
997: if (TREE_PRIVATE (field))
998: PRIVATE_RETURN;
999: /* We want to make sure that all non-private members in
1000: the current class (as derived) are accessible. */
1001: if (current_class_type
1002: && UNIQUELY_DERIVED_FROM_P (context, current_class_type))
1003: PUBLIC_RETURN;
1004: PROTECTED_RETURN;
1005: }
1006:
1007: if (visibility == visibility_private && current_class_type != NULL_TREE)
1008: {
1009: reverse_path (basetype_path);
1010:
1011: /* If it's private in the base class, it stays private. */
1012: if (TREE_PRIVATE (field))
1013: PRIVATE_RETURN;
1014:
1015: /* ARM $11.2: Specifying a base class private does not affect access
1016: to static members of the base class. */
1017: if ((TREE_CODE (field) != FUNCTION_DECL
1018: && TREE_STATIC (field))
1019: || (TREE_CODE (field) == FUNCTION_DECL
1020: && DECL_STATIC_FUNCTION_P (field)))
1021: PUBLIC_RETURN;
1022:
1023: /* If it's public or protected in the base class, it becomes
1024: private in the derived class. If we (the current_class_type)
1025: are not that immediately derived type that gets it as a
1026: private member, then the member is not visibile. */
1027: if (immediately_derived (context, current_class_type))
1028: PUBLIC_RETURN;
1029:
1030: PRIVATE_RETURN;
1031: }
1032:
1033: ret:
1034: reverse_path (basetype_path);
1035:
1036: if (visibility == visibility_public)
1037: DECL_PUBLIC (field) = 1;
1038: else if (visibility == visibility_protected)
1039: DECL_PROTECTED (field) = 1;
1040: else if (visibility == visibility_private)
1041: DECL_PRIVATE (field) = 1;
1042: else my_friendly_abort (96);
1043: return visibility;
1044: }
1045:
1046: /* Routine to see if the sub-object denoted by the binfo PARENT can be
1047: found as a base class and sub-object of the object denoted by
1048: BINFO. This routine relies upon binfos not being shared, except
1049: for binfos for virtual bases. */
1050: static int
1051: is_subobject_of_p (parent, binfo)
1052: tree parent, binfo;
1053: {
1054: tree binfos = BINFO_BASETYPES (binfo);
1055: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1056:
1057: if (parent == binfo)
1058: return 1;
1059:
1060: /* Process and/or queue base types. */
1061: for (i = 0; i < n_baselinks; i++)
1062: {
1063: tree base_binfo = TREE_VEC_ELT (binfos, i);
1064: if (TREE_VIA_VIRTUAL (base_binfo))
1065: base_binfo = TYPE_BINFO (BINFO_TYPE (base_binfo));
1066: if (is_subobject_of_p (parent, base_binfo))
1067: return 1;
1068: }
1069: return 0;
1070: }
1071:
1072: /* See if a one FIELD_DECL hides another. This routine is meant to
1073: correspond to ANSI working paper Sept 17, 1992 10p4. The two
1074: binfos given are the binfos corresponding to the particular places
1075: the FIELD_DECLs are found. This routine relies upon binfos not
1076: being shared, except for virtual bases. */
1077: static int
1078: hides (hider_binfo, hidee_binfo)
1079: tree hider_binfo, hidee_binfo;
1080: {
1081: /* hider hides hidee, if hider has hidee as a base class and
1082: the instance of hidee is a sub-object of hider. The first
1083: part is always true is the second part is true.
1084:
1085: When hider and hidee are the same (two ways to get to the exact
1086: same member) we consider either one as hiding the other. */
1087: return is_subobject_of_p (hidee_binfo, hider_binfo);
1088: }
1089:
1090: /* Very similar to lookup_fnfields_1 but it ensures that at least one
1091: function was declared inside the class given by TYPE. It really should
1092: only return functions that match the given TYPE. */
1093: static int
1094: lookup_fnfields_here (type, name)
1095: tree type, name;
1096: {
1097: int index = lookup_fnfields_1 (type, name);
1098: tree fndecls;
1099:
1100: if (index <= 0)
1101: return index;
1102: fndecls = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index);
1103: while (fndecls)
1104: {
1105: if (TYPE_MAIN_VARIANT (DECL_CLASS_CONTEXT (fndecls))
1106: == TYPE_MAIN_VARIANT (type))
1107: return index;
1108: fndecls = TREE_CHAIN (fndecls);
1109: }
1110: return -1;
1111: }
1112:
1113: /* Look for a field named NAME in an inheritance lattice dominated by
1114: XBASETYPE. PROTECT is zero if we can avoid computing visibility
1115: information, otherwise it is 1. WANT_TYPE is 1 when we should only
1116: return TYPE_DECLs, if no TYPE_DECL can be found return NULL_TREE.
1117:
1118: It was not clear what should happen if WANT_TYPE is set, and an
1119: ambiguity is found. At least one use (lookup_name) to not see
1120: the error. */
1121: tree
1122: lookup_field (xbasetype, name, protect, want_type)
1123: register tree xbasetype, name;
1124: int protect, want_type;
1125: {
1126: int head = 0, tail = 0;
1127: tree rval, rval_binfo = NULL_TREE, rval_binfo_h;
1128: tree type, basetype_chain, basetype_path;
1129: enum visibility_type this_v = visibility_default;
1130: tree entry, binfo, binfo_h;
1131: enum visibility_type own_visibility = visibility_default;
1132: int vbase_name_p = VBASE_NAME_P (name);
1133:
1134: /* rval_binfo is the binfo associated with the found member, note,
1135: this can be set with useful information, even when rval is not
1136: set, because it must deal with ALL members, not just non-function
1137: members. It is used for ambiguity checking and the hidden
1138: checks. Whereas rval is only set if a proper (not hidden)
1139: non-function member is found. */
1140:
1141: /* rval_binfo_h and binfo_h are binfo values used when we perform the
1142: hiding checks, as virtual base classes may not be shared. The strategy
1143: is we always go into the the binfo hierarchy owned by TYPE_BINFO of
1144: virtual base classes, as we cross virtual base class lines. This way
1145: we know that binfo of a virtual base class will always == itself when
1146: found along any line. (mrs) */
1147:
1148: /* Things for memoization. */
1149: char *errstr = 0;
1150:
1151: /* Set this to nonzero if we don't know how to compute
1152: accurate error messages for visibility. */
1153: int index = MEMOIZED_HASH_FN (name);
1154:
1155: /* If we are looking for a constructor in a templated type, use the
1156: unspecialized name, as that is how we store it. */
1157: if (IDENTIFIER_TEMPLATE (name))
1158: name = constructor_name (name);
1159:
1160: if (TREE_CODE (xbasetype) == TREE_VEC)
1161: basetype_path = xbasetype, type = BINFO_TYPE (xbasetype);
1162: else if (IS_AGGR_TYPE_CODE (TREE_CODE (xbasetype)))
1163: basetype_path = TYPE_BINFO (xbasetype), type = xbasetype;
1164: else my_friendly_abort (97);
1165:
1166: if (CLASSTYPE_MTABLE_ENTRY (type))
1167: {
1168: tree tem = MEMOIZED_FIELDS (CLASSTYPE_MTABLE_ENTRY (type), index);
1169:
1170: while (tem && TREE_PURPOSE (tem) != name)
1171: {
1172: memoized_fields_searched[0]++;
1173: tem = TREE_CHAIN (tem);
1174: }
1175: if (tem)
1176: {
1177: if (protect && TREE_TYPE (tem))
1178: {
1179: error (TREE_STRING_POINTER (TREE_TYPE (tem)),
1180: IDENTIFIER_POINTER (name),
1181: TYPE_NAME_STRING (DECL_FIELD_CONTEXT (TREE_VALUE (tem))));
1182: return error_mark_node;
1183: }
1184: if (TREE_VALUE (tem) == NULL_TREE)
1185: memoized_fast_rejects[0] += 1;
1186: else
1187: memoized_fast_finds[0] += 1;
1188: return TREE_VALUE (tem);
1189: }
1190: }
1191:
1192: #ifdef GATHER_STATISTICS
1193: n_calls_lookup_field++;
1194: #endif
1195: if (protect && flag_memoize_lookups && ! global_bindings_p ())
1196: entry = make_memoized_table_entry (type, name, 0);
1197: else
1198: entry = 0;
1199:
1200: rval = lookup_field_1 (type, name);
1201: if (rval || lookup_fnfields_here (type, name)>=0)
1202: {
1203: rval_binfo = basetype_path;
1204: rval_binfo_h = rval_binfo;
1205: }
1206:
1207: if (rval && TREE_CODE (rval) != TYPE_DECL && want_type)
1208: rval = NULL_TREE;
1209:
1210: if (rval)
1211: {
1212: if (protect)
1213: {
1214: if (TREE_PRIVATE (rval) | TREE_PROTECTED (rval))
1215: this_v = compute_visibility (basetype_path, rval);
1216: if (TREE_CODE (rval) == CONST_DECL)
1217: {
1218: if (this_v == visibility_private)
1219: errstr = "enum `%s' is a private value of class `%s'";
1220: else if (this_v == visibility_protected)
1221: errstr = "enum `%s' is a protected value of class `%s'";
1222: }
1223: else
1224: {
1225: if (this_v == visibility_private)
1226: errstr = "member `%s' is a private member of class `%s'";
1227: else if (this_v == visibility_protected)
1228: errstr = "member `%s' is a protected member of class `%s'";
1229: }
1230: }
1231:
1232: if (entry)
1233: {
1234: if (errstr)
1235: {
1236: /* This depends on behavior of lookup_field_1! */
1237: tree error_string = my_build_string (errstr);
1238: TREE_TYPE (entry) = error_string;
1239: }
1240: else
1241: {
1242: /* Let entry know there is no problem with this access. */
1243: TREE_TYPE (entry) = NULL_TREE;
1244: }
1245: TREE_VALUE (entry) = rval;
1246: }
1247:
1248: if (errstr && protect)
1249: {
1250: error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type));
1251: return error_mark_node;
1252: }
1253: return rval;
1254: }
1255:
1256: basetype_chain = CLASSTYPE_BINFO_AS_LIST (type);
1257: TREE_VIA_PUBLIC (basetype_chain) = 1;
1258:
1259: /* The ambiguity check relies upon breadth first searching. */
1260:
1261: search_stack = push_search_level (search_stack, &search_obstack);
1262: BINFO_VIA_PUBLIC (basetype_path) = 1;
1263: BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
1264: binfo = basetype_path;
1265: binfo_h = binfo;
1266:
1267: while (1)
1268: {
1269: tree binfos = BINFO_BASETYPES (binfo);
1270: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1271: tree nval;
1272:
1273: /* Process and/or queue base types. */
1274: for (i = 0; i < n_baselinks; i++)
1275: {
1276: tree base_binfo = TREE_VEC_ELT (binfos, i);
1277: if (BINFO_FIELDS_MARKED (base_binfo) == 0)
1278: {
1279: tree btypes;
1280:
1281: SET_BINFO_FIELDS_MARKED (base_binfo);
1282: btypes = my_tree_cons (NULL_TREE, base_binfo, basetype_chain);
1283: TREE_VIA_PUBLIC (btypes) = TREE_VIA_PUBLIC (base_binfo);
1284: TREE_VIA_PROTECTED (btypes) = TREE_VIA_PROTECTED (base_binfo);
1285: TREE_VIA_VIRTUAL (btypes) = TREE_VIA_VIRTUAL (base_binfo);
1286: if (TREE_VIA_VIRTUAL (base_binfo))
1287: btypes = tree_cons (NULL_TREE,
1288: TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i))),
1289: btypes);
1290: else
1291: btypes = tree_cons (NULL_TREE,
1292: TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i),
1293: btypes);
1294: obstack_ptr_grow (&search_obstack, btypes);
1295: tail += 1;
1296: if (tail >= search_stack->limit)
1297: my_friendly_abort (98);
1298: }
1299: }
1300:
1301: /* Process head of queue, if one exists. */
1302: if (head >= tail)
1303: break;
1304:
1305: basetype_chain = search_stack->first[head++];
1306: binfo_h = TREE_VALUE (basetype_chain);
1307: basetype_chain = TREE_CHAIN (basetype_chain);
1308: basetype_path = TREE_VALUE (basetype_chain);
1309: if (TREE_CHAIN (basetype_chain))
1310: BINFO_INHERITANCE_CHAIN (basetype_path) = TREE_VALUE (TREE_CHAIN (basetype_chain));
1311: else
1312: BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
1313:
1314: binfo = basetype_path;
1315: type = BINFO_TYPE (binfo);
1316:
1317: /* See if we can find NAME in TYPE. If RVAL is nonzero,
1318: and we do find NAME in TYPE, verify that such a second
1319: sighting is in fact legal. */
1320:
1321: nval = lookup_field_1 (type, name);
1322:
1323: if (nval || lookup_fnfields_here (type, name)>=0)
1324: {
1325: if (rval_binfo && hides (rval_binfo_h, binfo_h))
1326: {
1327: /* This is ok, the member found is in rval_binfo, not
1328: here (binfo). */
1329: }
1330: else if (rval_binfo==NULL_TREE || hides (binfo_h, rval_binfo_h))
1331: {
1332: /* This is ok, the member found is here (binfo), not in
1333: rval_binfo. */
1334: if (nval)
1335: {
1336: rval = nval;
1337: if (entry || protect)
1338: this_v = compute_visibility (basetype_path, rval);
1339: /* These may look ambiguous, but they really are not. */
1340: if (vbase_name_p)
1341: break;
1342: }
1343: else
1344: {
1345: /* Undo finding it before, as something else hides it. */
1346: rval = NULL_TREE;
1347: }
1348: rval_binfo = binfo;
1349: rval_binfo_h = binfo_h;
1350: }
1351: else
1352: {
1353: /* This is ambiguous. */
1354: errstr = "request for member `%s' is ambiguous";
1355: protect = 2;
1356: break;
1357: }
1358: }
1359: }
1360: {
1361: tree *tp = search_stack->first;
1362: tree *search_tail = tp + tail;
1363:
1364: if (entry)
1365: TREE_VALUE (entry) = rval;
1366:
1367: if (want_type && (rval == NULL_TREE || TREE_CODE (rval) != TYPE_DECL))
1368: {
1369: rval = NULL_TREE;
1370: errstr = 0;
1371: }
1372:
1373: /* If this FIELD_DECL defines its own visibility, deal with that. */
1374: if (rval && errstr == 0
1375: && ((protect&1) || entry)
1376: && DECL_LANG_SPECIFIC (rval)
1377: && DECL_VISIBILITY (rval))
1378: {
1379: while (tp < search_tail)
1380: {
1381: /* If is possible for one of the derived types on the
1382: path to have defined special visibility for this
1383: field. Look for such declarations and report an
1384: error if a conflict is found. */
1385: enum visibility_type new_v;
1386:
1387: if (this_v != visibility_default)
1388: new_v = compute_visibility (TREE_VALUE (TREE_CHAIN (*tp)), rval);
1389: if (this_v != visibility_default && new_v != this_v)
1390: {
1391: errstr = "conflicting visibilities to member `%s'";
1392: this_v = visibility_default;
1393: }
1394: own_visibility = new_v;
1395: CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp)));
1396: tp += 1;
1397: }
1398: }
1399: else
1400: {
1401: while (tp < search_tail)
1402: {
1403: CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp)));
1404: tp += 1;
1405: }
1406: }
1407: }
1408: search_stack = pop_search_level (search_stack);
1409:
1410: if (errstr == 0)
1411: {
1412: if (own_visibility == visibility_private)
1413: errstr = "member `%s' declared private";
1414: else if (own_visibility == visibility_protected)
1415: errstr = "member `%s' declared protected";
1416: else if (this_v == visibility_private)
1417: errstr = TREE_PRIVATE (rval)
1418: ? "member `%s' is private"
1419: : "member `%s' is from private base class";
1420: else if (this_v == visibility_protected)
1421: errstr = TREE_PROTECTED (rval)
1422: ? "member `%s' is protected"
1423: : "member `%s' is from protected base class";
1424: }
1425:
1426: if (entry)
1427: {
1428: if (errstr)
1429: {
1430: tree error_string = my_build_string (errstr);
1431: /* Save error message with entry. */
1432: TREE_TYPE (entry) = error_string;
1433: }
1434: else
1435: {
1436: /* Mark entry as having no error string. */
1437: TREE_TYPE (entry) = NULL_TREE;
1438: }
1439: }
1440:
1441: if (errstr && protect)
1442: {
1443: char *p = IDENTIFIER_POINTER (name), *q = NULL;
1444: if (IDENTIFIER_OPNAME_P (name))
1445: {
1446: q = operator_name_string (name);
1447: p = (char *) xmalloc (9 + strlen (q) + 1);
1448: sprintf (p, "operator %s", q);
1449: }
1450:
1451: error (errstr, p, TYPE_NAME_STRING (type));
1452: if (q)
1453: free (p);
1454: rval = error_mark_node;
1455: }
1456: return rval;
1457: }
1458:
1459: /* Try to find NAME inside a nested class. */
1460: tree
1461: lookup_nested_field (name, complain)
1462: tree name;
1463: int complain;
1464: {
1465: register tree t;
1466:
1467: tree id = NULL_TREE;
1468: if (TREE_CHAIN (current_class_type))
1469: {
1470: /* Climb our way up the nested ladder, seeing if we're trying to
1471: modify a field in an enclosing class. If so, we should only
1472: be able to modify if it's static. */
1473: for (t = TREE_CHAIN (current_class_type);
1474: t && DECL_CONTEXT (t);
1475: t = TREE_CHAIN (DECL_CONTEXT (t)))
1476: {
1477: if (TREE_CODE (DECL_CONTEXT (t)) != RECORD_TYPE)
1478: break;
1479:
1480: /* N.B.: lookup_field will do the visibility checking for us */
1481: id = lookup_field (DECL_CONTEXT (t), name, complain, 0);
1482: if (id == error_mark_node)
1483: {
1484: id = NULL_TREE;
1485: continue;
1486: }
1487:
1488: if (id != NULL_TREE)
1489: {
1490: if (TREE_CODE (id) == FIELD_DECL
1491: && ! TREE_STATIC (id)
1492: && TREE_TYPE (id) != error_mark_node)
1493: {
1494: if (complain)
1495: {
1496: /* At parse time, we don't want to give this error, since
1497: we won't have enough state to make this kind of
1498: decision properly. But there are times (e.g., with
1499: enums in nested classes) when we do need to call
1500: this fn at parse time. So, in those cases, we pass
1501: complain as a 0 and just return a NULL_TREE. */
1502: error ("assignment to non-static member `%s' of enclosing class `%s'",
1503: lang_printable_name (id),
1504: IDENTIFIER_POINTER (TYPE_IDENTIFIER
1505: (DECL_CONTEXT (t))));
1506: /* Mark this for do_identifier(). It would otherwise
1507: claim that the variable was undeclared. */
1508: TREE_TYPE (id) = error_mark_node;
1509: }
1510: else
1511: {
1512: id = NULL_TREE;
1513: continue;
1514: }
1515: }
1516: break;
1517: }
1518: }
1519: }
1520:
1521: return id;
1522: }
1523:
1524: /* TYPE is a class type. Return the index of the fields within
1525: the method vector with name NAME, or -1 is no such field exists. */
1526: static int
1527: lookup_fnfields_1 (type, name)
1528: tree type, name;
1529: {
1530: register tree method_vec = CLASSTYPE_METHOD_VEC (type);
1531:
1532: if (method_vec != 0)
1533: {
1534: register tree *methods = &TREE_VEC_ELT (method_vec, 0);
1535: register tree *end = TREE_VEC_END (method_vec);
1536:
1537: #ifdef GATHER_STATISTICS
1538: n_calls_lookup_fnfields_1++;
1539: #endif
1540: if (*methods && name == constructor_name (type))
1541: return 0;
1542:
1543: while (++methods != end)
1544: {
1545: #ifdef GATHER_STATISTICS
1546: n_outer_fields_searched++;
1547: #endif
1548: if (DECL_NAME (*methods) == name)
1549: break;
1550: }
1551: if (methods != end)
1552: return methods - &TREE_VEC_ELT (method_vec, 0);
1553: }
1554:
1555: return -1;
1556: }
1557:
1558: /* Starting from BASETYPE, return a TREE_BASELINK-like object
1559: which gives the following information (in a list):
1560:
1561: TREE_TYPE: list of basetypes needed to get to...
1562: TREE_VALUE: list of all functions in of given type
1563: which have name NAME.
1564:
1565: No visibility information is computed by this function,
1566: other then to adorn the list of basetypes with
1567: TREE_VIA_PUBLIC.
1568:
1569: If there are two ways to find a name (two members), if COMPLAIN is
1570: non-zero, then error_mark_node is returned, and an error message is
1571: printed, otherwise, just an error_mark_node is returned.
1572:
1573: As a special case, is COMPLAIN is -1, we don't complain, and we
1574: don't return error_mark_node, but rather the complete list of
1575: virtuals. This is used by get_virtuals_named_this. */
1576: tree
1577: lookup_fnfields (basetype_path, name, complain)
1578: tree basetype_path, name;
1579: int complain;
1580: {
1581: int head = 0, tail = 0;
1582: tree type, rval, rval_binfo = NULL_TREE, rvals = NULL_TREE, rval_binfo_h;
1583: tree entry, binfo, basetype_chain, binfo_h;
1584: int find_all = 0;
1585:
1586: /* rval_binfo is the binfo associated with the found member, note,
1587: this can be set with useful information, even when rval is not
1588: set, because it must deal with ALL members, not just function
1589: members. It is used for ambiguity checking and the hidden
1590: checks. Whereas rval is only set if a proper (not hidden)
1591: function member is found. */
1592:
1593: /* rval_binfo_h and binfo_h are binfo values used when we perform the
1594: hiding checks, as virtual base classes may not be shared. The strategy
1595: is we always go into the the binfo hierarchy owned by TYPE_BINFO of
1596: virtual base classes, as we cross virtual base class lines. This way
1597: we know that binfo of a virtual base class will always == itself when
1598: found along any line. (mrs) */
1599:
1600: /* For now, don't try this. */
1601: int protect = complain;
1602:
1603: /* Things for memoization. */
1604: char *errstr = 0;
1605:
1606: /* Set this to nonzero if we don't know how to compute
1607: accurate error messages for visibility. */
1608: int index = MEMOIZED_HASH_FN (name);
1609:
1610: if (complain == -1)
1611: {
1612: find_all = 1;
1613: protect = complain = 0;
1614: }
1615:
1616: /* If we are looking for a constructor in a templated type, use the
1617: unspecialized name, as that is how we store it. */
1618: if (IDENTIFIER_TEMPLATE (name))
1619: name = constructor_name (name);
1620:
1621: binfo = basetype_path;
1622: binfo_h = binfo;
1623: type = BINFO_TYPE (basetype_path);
1624:
1625: /* The memoization code is in need of maintenance. */
1626: if (!find_all && CLASSTYPE_MTABLE_ENTRY (type))
1627: {
1628: tree tem = MEMOIZED_FNFIELDS (CLASSTYPE_MTABLE_ENTRY (type), index);
1629:
1630: while (tem && TREE_PURPOSE (tem) != name)
1631: {
1632: memoized_fields_searched[1]++;
1633: tem = TREE_CHAIN (tem);
1634: }
1635: if (tem)
1636: {
1637: if (protect && TREE_TYPE (tem))
1638: {
1639: error (TREE_STRING_POINTER (TREE_TYPE (tem)),
1640: IDENTIFIER_POINTER (name),
1641: TYPE_NAME_STRING (DECL_CLASS_CONTEXT (TREE_VALUE (TREE_VALUE (tem)))));
1642: return error_mark_node;
1643: }
1644: if (TREE_VALUE (tem) == NULL_TREE)
1645: {
1646: memoized_fast_rejects[1] += 1;
1647: return NULL_TREE;
1648: }
1649: else
1650: {
1651: /* Want to return this, but we must make sure
1652: that visibility information is consistent. */
1653: tree baselink = TREE_VALUE (tem);
1654: tree memoized_basetypes = TREE_PURPOSE (baselink);
1655: tree these_basetypes = basetype_path;
1656: while (memoized_basetypes && these_basetypes)
1657: {
1658: memoized_fields_searched[1]++;
1659: if (TREE_VALUE (memoized_basetypes) != these_basetypes)
1660: break;
1661: memoized_basetypes = TREE_CHAIN (memoized_basetypes);
1662: these_basetypes = BINFO_INHERITANCE_CHAIN (these_basetypes);
1663: }
1664: /* The following statement is true only when both are NULL. */
1665: if (memoized_basetypes == these_basetypes)
1666: {
1667: memoized_fast_finds[1] += 1;
1668: return TREE_VALUE (tem);
1669: }
1670: /* else, we must re-find this field by hand. */
1671: baselink = tree_cons (basetype_path, TREE_VALUE (baselink), TREE_CHAIN (baselink));
1672: return baselink;
1673: }
1674: }
1675: }
1676:
1677: #ifdef GATHER_STATISTICS
1678: n_calls_lookup_fnfields++;
1679: #endif
1680: if (protect && flag_memoize_lookups && ! global_bindings_p ())
1681: entry = make_memoized_table_entry (type, name, 1);
1682: else
1683: entry = 0;
1684:
1685: index = lookup_fnfields_here (type, name);
1686: if (index >= 0 || lookup_field_1 (type, name))
1687: {
1688: rval_binfo = basetype_path;
1689: rval_binfo_h = rval_binfo;
1690: }
1691:
1692: if (index >= 0)
1693: {
1694: rval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index);
1695: rvals = my_tree_cons (basetype_path, rval, rvals);
1696: if (BINFO_BASETYPES (binfo) && CLASSTYPE_BASELINK_VEC (type))
1697: TREE_TYPE (rvals) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), index);
1698:
1699: if (entry)
1700: {
1701: TREE_VALUE (entry) = rvals;
1702: TREE_TYPE (entry) = NULL_TREE;
1703: }
1704:
1705: if (errstr && protect)
1706: {
1707: error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type));
1708: return error_mark_node;
1709: }
1710: return rvals;
1711: }
1712: rval = NULL_TREE;
1713:
1714: basetype_chain = CLASSTYPE_BINFO_AS_LIST (type);
1715: TREE_VIA_PUBLIC (basetype_chain) = 1;
1716:
1717: /* The ambiguity check relies upon breadth first searching. */
1718:
1719: search_stack = push_search_level (search_stack, &search_obstack);
1720: BINFO_VIA_PUBLIC (basetype_path) = 1;
1721: BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
1722: binfo = basetype_path;
1723: binfo_h = binfo;
1724:
1725: while (1)
1726: {
1727: tree binfos = BINFO_BASETYPES (binfo);
1728: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1729: int index;
1730:
1731: /* Process and/or queue base types. */
1732: for (i = 0; i < n_baselinks; i++)
1733: {
1734: tree base_binfo = TREE_VEC_ELT (binfos, i);
1735: if (BINFO_FIELDS_MARKED (base_binfo) == 0)
1736: {
1737: tree btypes;
1738:
1739: SET_BINFO_FIELDS_MARKED (base_binfo);
1740: btypes = my_tree_cons (NULL_TREE, base_binfo, basetype_chain);
1741: TREE_VIA_PUBLIC (btypes) = TREE_VIA_PUBLIC (base_binfo);
1742: TREE_VIA_PROTECTED (btypes) = TREE_VIA_PROTECTED (base_binfo);
1743: TREE_VIA_VIRTUAL (btypes) = TREE_VIA_VIRTUAL (base_binfo);
1744: if (TREE_VIA_VIRTUAL (base_binfo))
1745: btypes = tree_cons (NULL_TREE,
1746: TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i))),
1747: btypes);
1748: else
1749: btypes = tree_cons (NULL_TREE,
1750: TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i),
1751: btypes);
1752: obstack_ptr_grow (&search_obstack, btypes);
1753: tail += 1;
1754: if (tail >= search_stack->limit)
1755: my_friendly_abort (99);
1756: }
1757: }
1758:
1759: /* Process head of queue, if one exists. */
1760: if (head >= tail)
1761: break;
1762:
1763: basetype_chain = search_stack->first[head++];
1764: binfo_h = TREE_VALUE (basetype_chain);
1765: basetype_chain = TREE_CHAIN (basetype_chain);
1766: basetype_path = TREE_VALUE (basetype_chain);
1767: if (TREE_CHAIN (basetype_chain))
1768: BINFO_INHERITANCE_CHAIN (basetype_path) = TREE_VALUE (TREE_CHAIN (basetype_chain));
1769: else
1770: BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE;
1771:
1772: binfo = basetype_path;
1773: type = BINFO_TYPE (binfo);
1774:
1775: /* See if we can find NAME in TYPE. If RVAL is nonzero,
1776: and we do find NAME in TYPE, verify that such a second
1777: sighting is in fact legal. */
1778:
1779: index = lookup_fnfields_here (type, name);
1780:
1781: if (index >= 0 || (lookup_field_1 (type, name)!=NULL_TREE && !find_all))
1782: {
1783: if (rval_binfo && !find_all && hides (rval_binfo_h, binfo_h))
1784: {
1785: /* This is ok, the member found is in rval_binfo, not
1786: here (binfo). */
1787: }
1788: else if (rval_binfo==NULL_TREE || find_all || hides (binfo_h, rval_binfo_h))
1789: {
1790: /* This is ok, the member found is here (binfo), not in
1791: rval_binfo. */
1792: if (index >= 0)
1793: {
1794: rval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index);
1795: /* Note, rvals can only be previously set if find_all is
1796: true. */
1797: rvals = my_tree_cons (basetype_path, rval, rvals);
1798: if (TYPE_BINFO_BASETYPES (type)
1799: && CLASSTYPE_BASELINK_VEC (type))
1800: TREE_TYPE (rvals) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), index);
1801: }
1802: else
1803: {
1804: /* Undo finding it before, as something else hides it. */
1805: rval = NULL_TREE;
1806: rvals = NULL_TREE;
1807: }
1808: rval_binfo = binfo;
1809: rval_binfo_h = binfo_h;
1810: }
1811: else
1812: {
1813: /* This is ambiguous. */
1814: errstr = "request for member `%s' is ambiguous";
1815: rvals = error_mark_node;
1816: break;
1817: }
1818: }
1819: }
1820: {
1821: tree *tp = search_stack->first;
1822: tree *search_tail = tp + tail;
1823:
1824: while (tp < search_tail)
1825: {
1826: CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp)));
1827: tp += 1;
1828: }
1829: }
1830: search_stack = pop_search_level (search_stack);
1831:
1832: if (entry)
1833: {
1834: if (errstr)
1835: {
1836: tree error_string = my_build_string (errstr);
1837: /* Save error message with entry. */
1838: TREE_TYPE (entry) = error_string;
1839: }
1840: else
1841: {
1842: /* Mark entry as having no error string. */
1843: TREE_TYPE (entry) = NULL_TREE;
1844: TREE_VALUE (entry) = rvals;
1845: }
1846: }
1847:
1848: if (errstr && protect)
1849: {
1850: error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type));
1851: rvals = error_mark_node;
1852: }
1853:
1854: return rvals;
1855: }
1856:
1857: /* BREADTH-FIRST SEARCH ROUTINES. */
1858:
1859: /* Search a multiple inheritance hierarchy by breadth-first search.
1860:
1861: TYPE is an aggregate type, possibly in a multiple-inheritance hierarchy.
1862: TESTFN is a function, which, if true, means that our condition has been met,
1863: and its return value should be returned.
1864: QFN, if non-NULL, is a predicate dictating whether the type should
1865: even be queued. */
1866:
1867: HOST_WIDE_INT
1868: breadth_first_search (binfo, testfn, qfn)
1869: tree binfo;
1870: int (*testfn)();
1871: int (*qfn)();
1872: {
1873: int head = 0, tail = 0;
1874: int rval = 0;
1875:
1876: search_stack = push_search_level (search_stack, &search_obstack);
1877:
1878: while (1)
1879: {
1880: tree binfos = BINFO_BASETYPES (binfo);
1881: int n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1882: int i;
1883:
1884: /* Process and/or queue base types. */
1885: for (i = 0; i < n_baselinks; i++)
1886: {
1887: tree base_binfo = TREE_VEC_ELT (binfos, i);
1888:
1889: if (BINFO_MARKED (base_binfo) == 0
1890: && (qfn == 0 || (*qfn) (binfo, i)))
1891: {
1892: SET_BINFO_MARKED (base_binfo);
1893: obstack_ptr_grow (&search_obstack, binfo);
1894: obstack_ptr_grow (&search_obstack, (HOST_WIDE_INT) i);
1895: tail += 2;
1896: if (tail >= search_stack->limit)
1897: my_friendly_abort (100);
1898: }
1899: }
1900: /* Process head of queue, if one exists. */
1901: if (head >= tail)
1902: {
1903: rval = 0;
1904: break;
1905: }
1906:
1907: binfo = search_stack->first[head++];
1908: i = (HOST_WIDE_INT) search_stack->first[head++];
1909: if (rval = (*testfn) (binfo, i))
1910: break;
1911: binfo = BINFO_BASETYPE (binfo, i);
1912: }
1913: {
1914: tree *tp = search_stack->first;
1915: tree *search_tail = tp + tail;
1916: while (tp < search_tail)
1917: {
1918: tree binfo = *tp++;
1919: int i = (HOST_WIDE_INT)(*tp++);
1920: CLEAR_BINFO_MARKED (BINFO_BASETYPE (binfo, i));
1921: }
1922: }
1923:
1924: search_stack = pop_search_level (search_stack);
1925: return rval;
1926: }
1927:
1928: /* Functions to use in breadth first searches. */
1929: typedef tree (*pft)();
1930: typedef int (*pfi)();
1931:
1932: int tree_needs_constructor_p (binfo, i)
1933: tree binfo;
1934: int i;
1935: {
1936: tree basetype;
1937: my_friendly_assert (i != 0, 296);
1938: basetype = BINFO_TYPE (BINFO_BASETYPE (binfo, i));
1939: return TYPE_NEEDS_CONSTRUCTOR (basetype);
1940: }
1941:
1942: static tree declarator;
1943:
1944: static tree
1945: get_virtuals_named_this (binfo)
1946: tree binfo;
1947: {
1948: tree fields;
1949:
1950: fields = lookup_fnfields (binfo, declarator, -1);
1951: /* fields cannot be error_mark_node */
1952:
1953: if (fields == 0)
1954: return 0;
1955:
1956: /* Get to the function decls, and return the first virtual function
1957: with this name, if there is one. */
1958: while (fields)
1959: {
1960: tree fndecl;
1961:
1962: for (fndecl = TREE_VALUE (fields); fndecl; fndecl = DECL_CHAIN (fndecl))
1963: if (DECL_VINDEX (fndecl))
1964: return fields;
1965: fields = next_baselink (fields);
1966: }
1967: return NULL_TREE;
1968: }
1969:
1970: static tree get_virtual_destructor (binfo, i)
1971: tree binfo;
1972: int i;
1973: {
1974: tree type = BINFO_TYPE (binfo);
1975: if (i >= 0)
1976: type = BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), i));
1977: if (TYPE_HAS_DESTRUCTOR (type)
1978: && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0)))
1979: return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0);
1980: return 0;
1981: }
1982:
1983: int tree_has_any_destructor_p (binfo, i)
1984: tree binfo;
1985: int i;
1986: {
1987: tree type = BINFO_TYPE (binfo);
1988: if (i >= 0)
1989: type = BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), i));
1990: return TYPE_NEEDS_DESTRUCTOR (type);
1991: }
1992:
1993: /* Given a class type TYPE, and a function decl FNDECL,
1994: look for the first function the TYPE's hierarchy which
1995: FNDECL could match as a virtual function.
1996:
1997: DTORP is nonzero if we are looking for a destructor. Destructors
1998: need special treatment because they do not match by name. */
1999: tree
2000: get_first_matching_virtual (binfo, fndecl, dtorp)
2001: tree binfo, fndecl;
2002: int dtorp;
2003: {
2004: tree tmp = NULL_TREE;
2005:
2006: /* Breadth first search routines start searching basetypes
2007: of TYPE, so we must perform first ply of search here. */
2008: if (dtorp)
2009: {
2010: if (tree_has_any_destructor_p (binfo, -1))
2011: tmp = get_virtual_destructor (binfo, -1);
2012:
2013: if (tmp)
2014: {
2015: if (get_base_distance (DECL_CONTEXT (tmp),
2016: DECL_CONTEXT (fndecl), 0, 0) > 0)
2017: DECL_CONTEXT (fndecl) = DECL_CONTEXT (tmp);
2018: return tmp;
2019: }
2020:
2021: tmp = (tree) breadth_first_search (binfo,
2022: (pfi) get_virtual_destructor,
2023: tree_has_any_destructor_p);
2024: if (tmp)
2025: {
2026: if (get_base_distance (DECL_CONTEXT (tmp),
2027: DECL_CONTEXT (fndecl), 0, 0) > 0)
2028: DECL_CONTEXT (fndecl) = DECL_CONTEXT (tmp);
2029: }
2030: return tmp;
2031: }
2032: else
2033: {
2034: tree drettype, dtypes, btypes, instptr_type;
2035: tree basetype = DECL_CLASS_CONTEXT (fndecl);
2036: tree baselink, best = NULL_TREE;
2037: tree name = DECL_ASSEMBLER_NAME (fndecl);
2038:
2039: declarator = DECL_NAME (fndecl);
2040: if (IDENTIFIER_VIRTUAL_P (declarator) == 0)
2041: return NULL_TREE;
2042:
2043: drettype = TREE_TYPE (TREE_TYPE (fndecl));
2044: dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2045: if (DECL_STATIC_FUNCTION_P (fndecl))
2046: instptr_type = NULL_TREE;
2047: else
2048: instptr_type = TREE_TYPE (TREE_VALUE (dtypes));
2049:
2050: for (baselink = get_virtuals_named_this (binfo);
2051: baselink; baselink = next_baselink (baselink))
2052: {
2053: for (tmp = TREE_VALUE (baselink); tmp; tmp = DECL_CHAIN (tmp))
2054: {
2055: if (! DECL_VINDEX (tmp))
2056: continue;
2057:
2058: btypes = TYPE_ARG_TYPES (TREE_TYPE (tmp));
2059: if (instptr_type == NULL_TREE)
2060: {
2061: if (compparms (TREE_CHAIN (btypes), dtypes, 3))
2062: /* Caller knows to give error in this case. */
2063: return tmp;
2064: return NULL_TREE;
2065: }
2066:
2067: if ((TYPE_READONLY (TREE_TYPE (TREE_VALUE (btypes)))
2068: == TYPE_READONLY (instptr_type))
2069: && compparms (TREE_CHAIN (btypes), TREE_CHAIN (dtypes), 3))
2070: {
2071: if (IDENTIFIER_ERROR_LOCUS (name) == NULL_TREE
2072: && ! comptypes (TREE_TYPE (TREE_TYPE (tmp)), drettype, 1))
2073: {
2074: cp_error ("conflicting return type specified for virtual function `%D'", fndecl);
2075: SET_IDENTIFIER_ERROR_LOCUS (name, basetype);
2076: }
2077: break;
2078: }
2079: }
2080: if (tmp)
2081: {
2082: /* If this is ambiguous, we will warn about it later. */
2083: if (best)
2084: {
2085: if (get_base_distance (DECL_CLASS_CONTEXT (best),
2086: DECL_CLASS_CONTEXT (tmp), 0, 0) > 0)
2087: best = tmp;
2088: }
2089: else
2090: best = tmp;
2091: }
2092: }
2093: if (best == NULL_TREE && warn_overloaded_virtual)
2094: cp_warning_at ("conflicting specification deriving virtual function `%D'", fndecl);
2095:
2096: if (best)
2097: {
2098: if (get_base_distance (DECL_CONTEXT (best),
2099: DECL_CONTEXT (fndecl), 0, 0) > 0)
2100: DECL_CONTEXT (fndecl) = DECL_CONTEXT (best);
2101: }
2102: return best;
2103: }
2104: }
2105:
2106: /* Return the list of virtual functions which are abstract in type TYPE.
2107: This information is cached, and so must be built on a
2108: non-temporary obstack. */
2109: tree
2110: get_abstract_virtuals (type)
2111: tree type;
2112: {
2113: /* For each layer of base class (i.e., the first base class, and each
2114: virtual base class from that one), modify the virtual function table
2115: of the derived class to contain the new virtual function.
2116: A class has as many vfields as it has virtual base classes (total). */
2117: tree vfields, vbases, base, tmp;
2118: tree vfield = CLASSTYPE_VFIELD (type);
2119: tree fcontext = vfield ? DECL_FCONTEXT (vfield) : NULL_TREE;
2120: tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (type);
2121:
2122: for (vfields = CLASSTYPE_VFIELDS (type); vfields; vfields = TREE_CHAIN (vfields))
2123: {
2124: int normal;
2125:
2126: /* This code is most likely wrong, and probably only works for single
2127: inheritance or by accident. */
2128:
2129: /* Find the right base class for this derived class, call it BASE. */
2130: base = VF_BASETYPE_VALUE (vfields);
2131: if (base == type)
2132: continue;
2133:
2134: /* We call this case NORMAL iff this virtual function table
2135: pointer field has its storage reserved in this class.
2136: This is normally the case without virtual baseclasses
2137: or off-center multiple baseclasses. */
2138: normal = (base == fcontext
2139: && (VF_BINFO_VALUE (vfields) == NULL_TREE
2140: || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields))));
2141:
2142: if (normal)
2143: tmp = TREE_CHAIN (TYPE_BINFO_VIRTUALS (type));
2144: else
2145: {
2146: /* n.b.: VF_BASETYPE_VALUE (vfields) is the first basetype
2147: that provides the virtual function table, whereas
2148: VF_DERIVED_VALUE (vfields) is an immediate base type of TYPE
2149: that dominates VF_BASETYPE_VALUE (vfields). The list of
2150: vfields we want lies between these two values. */
2151: tree binfo = get_binfo (VF_NORMAL_VALUE (vfields), type, 0);
2152: tmp = TREE_CHAIN (BINFO_VIRTUALS (binfo));
2153: }
2154:
2155: /* Get around dossier entry if there is one. */
2156: if (flag_dossier)
2157: tmp = TREE_CHAIN (tmp);
2158:
2159: while (tmp)
2160: {
2161: tree base_pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (tmp));
2162: tree base_fndecl = TREE_OPERAND (base_pfn, 0);
2163: if (DECL_ABSTRACT_VIRTUAL_P (base_fndecl))
2164: abstract_virtuals = tree_cons (NULL_TREE, base_fndecl, abstract_virtuals);
2165: tmp = TREE_CHAIN (tmp);
2166: }
2167: }
2168: for (vbases = CLASSTYPE_VBASECLASSES (type); vbases; vbases = TREE_CHAIN (vbases))
2169: {
2170: if (! BINFO_VIRTUALS (vbases))
2171: continue;
2172:
2173: tmp = TREE_CHAIN (BINFO_VIRTUALS (vbases));
2174: while (tmp)
2175: {
2176: tree base_pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (tmp));
2177: tree base_fndecl = TREE_OPERAND (base_pfn, 0);
2178: if (DECL_ABSTRACT_VIRTUAL_P (base_fndecl))
2179: abstract_virtuals = tree_cons (NULL_TREE, base_fndecl, abstract_virtuals);
2180: tmp = TREE_CHAIN (tmp);
2181: }
2182: }
2183: return nreverse (abstract_virtuals);
2184: }
2185:
2186: /* For the type TYPE, return a list of member functions available from
2187: base classes with name NAME. The TREE_VALUE of the list is a chain of
2188: member functions with name NAME. The TREE_PURPOSE of the list is a
2189: basetype, or a list of base types (in reverse order) which were
2190: traversed to reach the chain of member functions. If we reach a base
2191: type which provides a member function of name NAME, and which has at
2192: most one base type itself, then we can terminate the search. */
2193:
2194: tree
2195: get_baselinks (type_as_binfo_list, type, name)
2196: tree type_as_binfo_list;
2197: tree type, name;
2198: {
2199: int head = 0, tail = 0, index;
2200: tree rval = 0, nval = 0;
2201: tree basetypes = type_as_binfo_list;
2202: tree binfo = TYPE_BINFO (type);
2203:
2204: search_stack = push_search_level (search_stack, &search_obstack);
2205:
2206: while (1)
2207: {
2208: tree binfos = BINFO_BASETYPES (binfo);
2209: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2210:
2211: /* Process and/or queue base types. */
2212: for (i = 0; i < n_baselinks; i++)
2213: {
2214: tree base_binfo = TREE_VEC_ELT (binfos, i);
2215: tree btypes;
2216:
2217: btypes = hash_tree_cons (TREE_VIA_PUBLIC (base_binfo),
2218: TREE_VIA_VIRTUAL (base_binfo),
2219: TREE_VIA_PROTECTED (base_binfo),
2220: NULL_TREE, base_binfo,
2221: basetypes);
2222: obstack_ptr_grow (&search_obstack, btypes);
2223: search_stack->first = (tree *)obstack_base (&search_obstack);
2224: tail += 1;
2225: }
2226:
2227: dont_queue:
2228: /* Process head of queue, if one exists. */
2229: if (head >= tail)
2230: break;
2231:
2232: basetypes = search_stack->first[head++];
2233: binfo = TREE_VALUE (basetypes);
2234: type = BINFO_TYPE (binfo);
2235: index = lookup_fnfields_1 (type, name);
2236: if (index >= 0)
2237: {
2238: nval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index);
2239: rval = hash_tree_cons (0, 0, 0, basetypes, nval, rval);
2240: if (TYPE_BINFO_BASETYPES (type) == 0)
2241: goto dont_queue;
2242: else if (TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)) == 1)
2243: {
2244: if (CLASSTYPE_BASELINK_VEC (type))
2245: TREE_TYPE (rval) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), index);
2246: goto dont_queue;
2247: }
2248: }
2249: nval = NULL_TREE;
2250: }
2251:
2252: search_stack = pop_search_level (search_stack);
2253: return rval;
2254: }
2255:
2256: tree
2257: next_baselink (baselink)
2258: tree baselink;
2259: {
2260: tree tmp = TREE_TYPE (baselink);
2261: baselink = TREE_CHAIN (baselink);
2262: while (tmp)
2263: {
2264: /* @@ does not yet add previous base types. */
2265: baselink = tree_cons (TREE_PURPOSE (tmp), TREE_VALUE (tmp),
2266: baselink);
2267: TREE_TYPE (baselink) = TREE_TYPE (tmp);
2268: tmp = TREE_CHAIN (tmp);
2269: }
2270: return baselink;
2271: }
2272:
2273: /* DEPTH-FIRST SEARCH ROUTINES. */
2274:
2275: /* Assign unique numbers to _CLASSTYPE members of the lattice
2276: specified by TYPE. The root nodes are marked first; the nodes
2277: are marked depth-fisrt, left-right. */
2278:
2279: static int cid;
2280:
2281: /* Matrix implementing a relation from CLASSTYPE X CLASSTYPE => INT.
2282: Relation yields 1 if C1 <= C2, 0 otherwise. */
2283: typedef char mi_boolean;
2284: static mi_boolean *mi_matrix;
2285:
2286: /* Type for which this matrix is defined. */
2287: static tree mi_type;
2288:
2289: /* Size of the matrix for indexing purposes. */
2290: static int mi_size;
2291:
2292: /* Return nonzero if class C2 derives from class C1. */
2293: #define BINFO_DERIVES_FROM(C1, C2) \
2294: ((mi_matrix+mi_size*(BINFO_CID (C1)-1))[BINFO_CID (C2)-1])
2295: #define TYPE_DERIVES_FROM(C1, C2) \
2296: ((mi_matrix+mi_size*(CLASSTYPE_CID (C1)-1))[CLASSTYPE_CID (C2)-1])
2297: #define BINFO_DERIVES_FROM_STAR(C) \
2298: (mi_matrix+(BINFO_CID (C)-1))
2299:
2300: /* This routine converts a pointer to be a pointer of an immediate
2301: base class. The normal convert_pointer_to routine would diagnose
2302: the conversion as ambiguous, under MI code that has the base class
2303: as an ambiguous base class. */
2304: static tree
2305: convert_pointer_to_single_level (to_type, expr)
2306: tree to_type, expr;
2307: {
2308: tree binfo_of_derived;
2309: tree last;
2310:
2311: binfo_of_derived = TYPE_BINFO (TREE_TYPE (TREE_TYPE (expr)));
2312: last = get_binfo (to_type, TREE_TYPE (TREE_TYPE (expr)), 0);
2313: BINFO_INHERITANCE_CHAIN (last) = binfo_of_derived;
2314: BINFO_INHERITANCE_CHAIN (binfo_of_derived) = NULL_TREE;
2315: return build_vbase_path (PLUS_EXPR, TYPE_POINTER_TO (to_type), expr, last, 1);
2316: }
2317:
2318: /* The main function which implements depth first search.
2319:
2320: This routine has to remember the path it walked up, when
2321: dfs_init_vbase_pointers is the work function, as otherwise there
2322: would be no record. */
2323: static void
2324: dfs_walk (binfo, fn, qfn)
2325: tree binfo;
2326: void (*fn)();
2327: int (*qfn)();
2328: {
2329: tree binfos = BINFO_BASETYPES (binfo);
2330: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2331:
2332: for (i = 0; i < n_baselinks; i++)
2333: {
2334: tree base_binfo = TREE_VEC_ELT (binfos, i);
2335:
2336: if ((*qfn)(base_binfo))
2337: {
2338: if (fn == dfs_init_vbase_pointers)
2339: {
2340: /* When traversing an arbitrary MI hierarchy, we need to keep
2341: a record of the path we took to get down to the final base
2342: type, as otherwise there would be no record of it, and just
2343: trying to blindly convert at the bottom would be ambiguous.
2344:
2345: The easiest way is to do the conversions one step at a time,
2346: as we know we want the immediate base class at each step.
2347:
2348: The only special trick to converting one step at a time,
2349: is that when we hit the last virtual base class, we must
2350: use the SLOT value for it, and not use the normal convert
2351: routine. We use the last virtual base class, as in our
2352: implementation, we have pointers to all virtual base
2353: classes in the base object. */
2354:
2355: tree saved_vbase_decl_ptr_intermediate
2356: = vbase_decl_ptr_intermediate;
2357:
2358: if (TREE_VIA_VIRTUAL (base_binfo))
2359: {
2360: /* No need for the conversion here, as we know it is the
2361: right type. */
2362: vbase_decl_ptr_intermediate
2363: = (tree)CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (base_binfo));
2364: }
2365: else
2366: {
2367: vbase_decl_ptr_intermediate
2368: = convert_pointer_to_single_level (BINFO_TYPE (base_binfo),
2369: vbase_decl_ptr_intermediate);
2370: }
2371:
2372: dfs_walk (base_binfo, fn, qfn);
2373:
2374: vbase_decl_ptr_intermediate = saved_vbase_decl_ptr_intermediate;
2375: } else
2376: dfs_walk (base_binfo, fn, qfn);
2377: }
2378: }
2379:
2380: fn (binfo);
2381: }
2382:
2383: /* Predicate functions which serve for dfs_walk. */
2384: static int numberedp (binfo) tree binfo;
2385: { return BINFO_CID (binfo); }
2386: static int unnumberedp (binfo) tree binfo;
2387: { return BINFO_CID (binfo) == 0; }
2388:
2389: static int markedp (binfo) tree binfo;
2390: { return BINFO_MARKED (binfo); }
2391: static int bfs_markedp (binfo, i) tree binfo; int i;
2392: { return BINFO_MARKED (BINFO_BASETYPE (binfo, i)); }
2393: static int unmarkedp (binfo) tree binfo;
2394: { return BINFO_MARKED (binfo) == 0; }
2395: static int bfs_unmarkedp (binfo, i) tree binfo; int i;
2396: { return BINFO_MARKED (BINFO_BASETYPE (binfo, i)) == 0; }
2397: static int marked_vtable_pathp (binfo) tree binfo;
2398: { return BINFO_VTABLE_PATH_MARKED (binfo); }
2399: static int bfs_marked_vtable_pathp (binfo, i) tree binfo; int i;
2400: { return BINFO_VTABLE_PATH_MARKED (BINFO_BASETYPE (binfo, i)); }
2401: static int unmarked_vtable_pathp (binfo) tree binfo;
2402: { return BINFO_VTABLE_PATH_MARKED (binfo) == 0; }
2403: static int bfs_unmarked_vtable_pathp (binfo, i) tree binfo; int i;
2404: { return BINFO_VTABLE_PATH_MARKED (BINFO_BASETYPE (binfo, i)) == 0; }
2405: static int marked_new_vtablep (binfo) tree binfo;
2406: { return BINFO_NEW_VTABLE_MARKED (binfo); }
2407: static int bfs_marked_new_vtablep (binfo, i) tree binfo; int i;
2408: { return BINFO_NEW_VTABLE_MARKED (BINFO_BASETYPE (binfo, i)); }
2409: static int unmarked_new_vtablep (binfo) tree binfo;
2410: { return BINFO_NEW_VTABLE_MARKED (binfo) == 0; }
2411: static int bfs_unmarked_new_vtablep (binfo, i) tree binfo; int i;
2412: { return BINFO_NEW_VTABLE_MARKED (BINFO_BASETYPE (binfo, i)) == 0; }
2413:
2414: static int dfs_search_slot_nonempty_p (binfo) tree binfo;
2415: { return CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (binfo)) != 0; }
2416:
2417: static int dfs_debug_unmarkedp (binfo) tree binfo;
2418: { return CLASSTYPE_DEBUG_REQUESTED (BINFO_TYPE (binfo)) == 0; }
2419:
2420: /* The worker functions for `dfs_walk'. These do not need to
2421: test anything (vis a vis marking) if they are paired with
2422: a predicate function (above). */
2423:
2424: /* Assign each type within the lattice a number which is unique
2425: in the lattice. The first number assigned is 1. */
2426:
2427: static void
2428: dfs_number (binfo)
2429: tree binfo;
2430: {
2431: BINFO_CID (binfo) = ++cid;
2432: }
2433:
2434: static void
2435: dfs_unnumber (binfo)
2436: tree binfo;
2437: {
2438: BINFO_CID (binfo) = 0;
2439: }
2440:
2441: static void
2442: dfs_mark (binfo) tree binfo;
2443: { SET_BINFO_MARKED (binfo); }
2444:
2445: static void
2446: dfs_unmark (binfo) tree binfo;
2447: { CLEAR_BINFO_MARKED (binfo); }
2448:
2449: static void
2450: dfs_mark_vtable_path (binfo) tree binfo;
2451: { SET_BINFO_VTABLE_PATH_MARKED (binfo); }
2452:
2453: static void
2454: dfs_unmark_vtable_path (binfo) tree binfo;
2455: { CLEAR_BINFO_VTABLE_PATH_MARKED (binfo); }
2456:
2457: static void
2458: dfs_mark_new_vtable (binfo) tree binfo;
2459: { SET_BINFO_NEW_VTABLE_MARKED (binfo); }
2460:
2461: static void
2462: dfs_unmark_new_vtable (binfo) tree binfo;
2463: { CLEAR_BINFO_NEW_VTABLE_MARKED (binfo); }
2464:
2465: static void
2466: dfs_clear_search_slot (binfo) tree binfo;
2467: { CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (binfo)) = 0; }
2468:
2469: static void
2470: dfs_debug_mark (binfo)
2471: tree binfo;
2472: {
2473: tree t = BINFO_TYPE (binfo);
2474:
2475: /* Use heuristic that if there are virtual functions,
2476: ignore until we see a non-inline virtual function. */
2477: tree methods = CLASSTYPE_METHOD_VEC (t);
2478:
2479: CLASSTYPE_DEBUG_REQUESTED (t) = 1;
2480:
2481: /* If interface info is known, the value of (?@@?) is correct. */
2482: if (methods == 0
2483: || CLASSTYPE_INTERFACE_KNOWN (t)
2484: || (write_virtuals == 2 && TYPE_VIRTUAL_P (t)))
2485: return;
2486:
2487: /* If debug info is requested from this context for this type, supply it.
2488: If debug info is requested from another context for this type,
2489: see if some third context can supply it. */
2490: if (current_function_decl == NULL_TREE
2491: || DECL_CLASS_CONTEXT (current_function_decl) != t)
2492: {
2493: if (TREE_VEC_ELT (methods, 0))
2494: methods = TREE_VEC_ELT (methods, 0);
2495: else
2496: methods = TREE_VEC_ELT (methods, 1);
2497: while (methods)
2498: {
2499: if (DECL_VINDEX (methods)
2500: && DECL_SAVED_INSNS (methods) == 0
2501: && DECL_PENDING_INLINE_INFO (methods) == 0
2502: && DECL_ABSTRACT_VIRTUAL_P (methods) == 0)
2503: {
2504: /* Somebody, somewhere is going to have to define this
2505: virtual function. When they do, they will provide
2506: the debugging info. */
2507: return;
2508: }
2509: methods = TREE_CHAIN (methods);
2510: }
2511: }
2512: /* We cannot rely on some alien method to solve our problems,
2513: so we must write out the debug info ourselves. */
2514: if (write_symbols != DWARF_DEBUG)
2515: DECL_IGNORED_P (TYPE_NAME (t)) = 0;
2516: if (! TREE_ASM_WRITTEN (TYPE_NAME (t)))
2517: rest_of_type_compilation (t, global_bindings_p ());
2518: }
2519:
2520: /* Attach to the type of the virtual base class, the pointer to the
2521: virtual base class, given the global pointer vbase_decl_ptr. */
2522: static void
2523: dfs_find_vbases (binfo)
2524: tree binfo;
2525: {
2526: tree binfos = BINFO_BASETYPES (binfo);
2527: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2528:
2529: for (i = n_baselinks-1; i >= 0; i--)
2530: {
2531: tree base_binfo = TREE_VEC_ELT (binfos, i);
2532:
2533: if (TREE_VIA_VIRTUAL (base_binfo)
2534: && CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (base_binfo)) == 0)
2535: {
2536: tree vbase = BINFO_TYPE (base_binfo);
2537: tree binfo = binfo_member (vbase, vbase_types);
2538:
2539: CLASSTYPE_SEARCH_SLOT (vbase)
2540: = (char *) build (PLUS_EXPR, TYPE_POINTER_TO (vbase),
2541: vbase_decl_ptr, BINFO_OFFSET (binfo));
2542: }
2543: }
2544: SET_BINFO_VTABLE_PATH_MARKED (binfo);
2545: SET_BINFO_NEW_VTABLE_MARKED (binfo);
2546: }
2547:
2548: static void
2549: dfs_init_vbase_pointers (binfo)
2550: tree binfo;
2551: {
2552: tree type = BINFO_TYPE (binfo);
2553: tree fields = TYPE_FIELDS (type);
2554: tree path, this_vbase_ptr;
2555: int distance;
2556:
2557: CLEAR_BINFO_VTABLE_PATH_MARKED (binfo);
2558:
2559: /* If there is a dossier, it is the first field, though perhaps from
2560: the base class. Otherwise, the first fields are virtual base class
2561: pointer fields. */
2562: if (CLASSTYPE_DOSSIER (type) && VFIELD_NAME_P (DECL_NAME (fields)))
2563: /* Get past vtable for the object. */
2564: fields = TREE_CHAIN (fields);
2565:
2566: if (fields == NULL_TREE
2567: || DECL_NAME (fields) == NULL_TREE
2568: || ! VBASE_NAME_P (DECL_NAME (fields)))
2569: return;
2570:
2571: this_vbase_ptr = vbase_decl_ptr_intermediate;
2572:
2573: if (TYPE_POINTER_TO (type) != TREE_TYPE (this_vbase_ptr))
2574: my_friendly_abort (125);
2575:
2576: while (fields && DECL_NAME (fields)
2577: && VBASE_NAME_P (DECL_NAME (fields)))
2578: {
2579: tree ref = build (COMPONENT_REF, TREE_TYPE (fields),
2580: build_indirect_ref (this_vbase_ptr, NULL_PTR), fields);
2581: tree init = (tree)CLASSTYPE_SEARCH_SLOT (TREE_TYPE (TREE_TYPE (fields)));
2582: vbase_init_result = tree_cons (binfo_member (TREE_TYPE (TREE_TYPE (fields)),
2583: vbase_types),
2584: build_modify_expr (ref, NOP_EXPR, init),
2585: vbase_init_result);
2586: fields = TREE_CHAIN (fields);
2587: }
2588: }
2589:
2590: /* Sometimes this needs to clear both VTABLE_PATH and NEW_VTABLE. Other
2591: times, just NEW_VTABLE, but optimizer should make both with equal
2592: efficiency (though it does not currently). */
2593: static void
2594: dfs_clear_vbase_slots (binfo)
2595: tree binfo;
2596: {
2597: tree type = BINFO_TYPE (binfo);
2598: CLASSTYPE_SEARCH_SLOT (type) = 0;
2599: CLEAR_BINFO_VTABLE_PATH_MARKED (binfo);
2600: CLEAR_BINFO_NEW_VTABLE_MARKED (binfo);
2601: }
2602:
2603: tree
2604: init_vbase_pointers (type, decl_ptr)
2605: tree type;
2606: tree decl_ptr;
2607: {
2608: if (TYPE_USES_VIRTUAL_BASECLASSES (type))
2609: {
2610: int old_flag = flag_this_is_variable;
2611: tree binfo = TYPE_BINFO (type);
2612: flag_this_is_variable = -2;
2613: vbase_types = CLASSTYPE_VBASECLASSES (type);
2614: vbase_decl_ptr = decl_ptr;
2615: vbase_decl = build_indirect_ref (decl_ptr, NULL_PTR);
2616: vbase_decl_ptr_intermediate = vbase_decl_ptr;
2617: vbase_init_result = NULL_TREE;
2618: dfs_walk (binfo, dfs_find_vbases, unmarked_vtable_pathp);
2619: dfs_walk (binfo, dfs_init_vbase_pointers, marked_vtable_pathp);
2620: dfs_walk (binfo, dfs_clear_vbase_slots, marked_new_vtablep);
2621: flag_this_is_variable = old_flag;
2622: return vbase_init_result;
2623: }
2624: return 0;
2625: }
2626:
2627: /* Build a COMPOUND_EXPR which when expanded will generate the code
2628: needed to initialize all the virtual function table slots of all
2629: the virtual baseclasses. FOR_TYPE is the type which determines the
2630: virtual baseclasses to use; TYPE is the type of the object to which
2631: the initialization applies. TRUE_EXP is the true object we are
2632: initializing, and DECL_PTR is the pointer to the sub-object we
2633: are initializing.
2634:
2635: When USE_COMPUTED_OFFSETS is non-zero, we can assume that the
2636: object was laidout by a top-level contructor and the computed
2637: offsets are valid to store vtables. When zero, we must store new
2638: vtables through virtual baseclass pointers. */
2639:
2640: tree
2641: build_vbase_vtables_init (main_binfo, binfo, true_exp, decl_ptr,
2642: use_computed_offsets)
2643: tree main_binfo, binfo;
2644: tree true_exp, decl_ptr;
2645: int use_computed_offsets;
2646: {
2647: tree for_type = BINFO_TYPE (main_binfo);
2648: tree type = BINFO_TYPE (binfo);
2649: if (TYPE_USES_VIRTUAL_BASECLASSES (type))
2650: {
2651: int old_flag = flag_this_is_variable;
2652: tree vtable_init_result = NULL_TREE;
2653: tree vbases = CLASSTYPE_VBASECLASSES (type);
2654:
2655: vbase_types = CLASSTYPE_VBASECLASSES (for_type);
2656: vbase_decl_ptr = true_exp ? build_unary_op (ADDR_EXPR, true_exp, 0) : decl_ptr;
2657: vbase_decl = true_exp ? true_exp : build_indirect_ref (decl_ptr, NULL_PTR);
2658:
2659: if (use_computed_offsets)
2660: {
2661: /* This is an object of type IN_TYPE, */
2662: flag_this_is_variable = -2;
2663: dfs_walk (main_binfo, dfs_find_vbases, unmarked_new_vtablep);
2664: }
2665:
2666: /* Initialized with vtables of type TYPE. */
2667: while (vbases)
2668: {
2669: /* This time through, not every class's vtable
2670: is going to be initialized. That is, we only initialize
2671: the "last" vtable pointer. */
2672:
2673: if (CLASSTYPE_VSIZE (BINFO_TYPE (vbases)))
2674: {
2675: tree addr;
2676: tree vtbl = BINFO_VTABLE (vbases);
2677: tree init = build_unary_op (ADDR_EXPR, vtbl, 0);
2678: assemble_external (vtbl);
2679: TREE_USED (vtbl) = 1;
2680:
2681: if (use_computed_offsets)
2682: addr = (tree)CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (vbases));
2683: else
2684: addr = convert_pointer_to (vbases, vbase_decl_ptr);
2685:
2686: if (addr)
2687: {
2688: tree ref = build_vfield_ref (build_indirect_ref (addr, NULL_PTR),
2689: BINFO_TYPE (vbases));
2690: init = convert_force (TREE_TYPE (ref), init);
2691: vtable_init_result = tree_cons (NULL_TREE, build_modify_expr (ref, NOP_EXPR, init),
2692: vtable_init_result);
2693: }
2694: }
2695: vbases = TREE_CHAIN (vbases);
2696: }
2697:
2698: dfs_walk (binfo, dfs_clear_vbase_slots, marked_new_vtablep);
2699:
2700: flag_this_is_variable = old_flag;
2701: if (vtable_init_result)
2702: return build_compound_expr (vtable_init_result);
2703: }
2704: return error_mark_node;
2705: }
2706:
2707: void
2708: clear_search_slots (type)
2709: tree type;
2710: {
2711: dfs_walk (TYPE_BINFO (type),
2712: dfs_clear_search_slot, dfs_search_slot_nonempty_p);
2713: }
2714:
2715: /* get virtual base class types.
2716: This adds type to the vbase_types list in reverse dfs order.
2717: Ordering is very important, so don't change it. */
2718:
2719: static void
2720: dfs_get_vbase_types (binfo)
2721: tree binfo;
2722: {
2723: tree binfos = BINFO_BASETYPES (binfo);
2724: tree type = BINFO_TYPE (binfo);
2725: tree these_vbase_types = CLASSTYPE_VBASECLASSES (type);
2726: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2727:
2728: if (these_vbase_types)
2729: {
2730: while (these_vbase_types)
2731: {
2732: tree this_type = BINFO_TYPE (these_vbase_types);
2733:
2734: /* We really need to start from a fresh copy of this
2735: virtual basetype! CLASSTYPE_MARKED2 is the shortcut
2736: for BINFO_VBASE_MARKED. */
2737: if (! CLASSTYPE_MARKED2 (this_type))
2738: {
2739: vbase_types = make_binfo (integer_zero_node,
2740: this_type,
2741: TYPE_BINFO_VTABLE (this_type),
2742: TYPE_BINFO_VIRTUALS (this_type),
2743: vbase_types);
2744: TREE_VIA_VIRTUAL (vbase_types) = 1;
2745: SET_CLASSTYPE_MARKED2 (this_type);
2746: }
2747: these_vbase_types = TREE_CHAIN (these_vbase_types);
2748: }
2749: }
2750: else for (i = 0; i < n_baselinks; i++)
2751: {
2752: tree base_binfo = TREE_VEC_ELT (binfos, i);
2753: if (TREE_VIA_VIRTUAL (base_binfo) && ! BINFO_VBASE_MARKED (base_binfo))
2754: {
2755: vbase_types = make_binfo (integer_zero_node, BINFO_TYPE (base_binfo),
2756: BINFO_VTABLE (base_binfo),
2757: BINFO_VIRTUALS (base_binfo), vbase_types);
2758: TREE_VIA_VIRTUAL (vbase_types) = 1;
2759: SET_BINFO_VBASE_MARKED (base_binfo);
2760: }
2761: }
2762: SET_BINFO_MARKED (binfo);
2763: }
2764:
2765: /* Some virtual baseclasses might be virtual baseclasses for
2766: other virtual baseclasses. We sort the virtual baseclasses
2767: topologically: in the list returned, the first virtual base
2768: classes have no virtual baseclasses themselves, and any entry
2769: on the list has no dependency on virtual base classes later in the
2770: list. */
2771: tree
2772: get_vbase_types (type)
2773: tree type;
2774: {
2775: tree ordered_vbase_types = NULL_TREE, prev, next;
2776: tree vbases;
2777:
2778: vbase_types = NULL_TREE;
2779: dfs_walk (TYPE_BINFO (type), dfs_get_vbase_types, unmarkedp);
2780: dfs_walk (TYPE_BINFO (type), dfs_unmark, markedp);
2781: /* Rely upon the reverse dfs ordering from dfs_get_vbase_types, and now
2782: reverse it so that we get normal dfs ordering. */
2783: vbase_types = nreverse (vbase_types);
2784:
2785: /* Almost all of the below is not needed now. We should be able to just
2786: return vbase_types directly... (mrs) */
2787: while (vbase_types)
2788: {
2789: /* Now sort these types. This is essentially a bubble merge. */
2790:
2791: /* Farm out virtual baseclasses which have no marked ancestors. */
2792: for (vbases = vbase_types, prev = NULL_TREE;
2793: vbases; vbases = next)
2794: {
2795: next = TREE_CHAIN (vbases);
2796: /* If VBASES does not have any vbases itself, or it's
2797: topologically safe, it goes into the sorted list. */
2798: if (1 /* ANSI C++ specifies dfs ordering now. */
2799: || ! CLASSTYPE_VBASECLASSES (BINFO_TYPE (vbases))
2800: || BINFO_VBASE_MARKED (vbases) == 0)
2801: {
2802: if (prev)
2803: TREE_CHAIN (prev) = TREE_CHAIN (vbases);
2804: else
2805: vbase_types = TREE_CHAIN (vbases);
2806: TREE_CHAIN (vbases) = NULL_TREE;
2807: ordered_vbase_types = chainon (ordered_vbase_types, vbases);
2808: CLEAR_BINFO_VBASE_MARKED (vbases);
2809: }
2810: else
2811: prev = vbases;
2812: }
2813:
2814: /* Now unmark types all of whose ancestors are now on the
2815: `ordered_vbase_types' list. */
2816: for (vbases = vbase_types; vbases; vbases = TREE_CHAIN (vbases))
2817: {
2818: /* If all our virtual baseclasses are unmarked, ok. */
2819: tree t = CLASSTYPE_VBASECLASSES (BINFO_TYPE (vbases));
2820: while (t && (BINFO_VBASE_MARKED (t) == 0
2821: || ! CLASSTYPE_VBASECLASSES (BINFO_TYPE (t))))
2822: t = TREE_CHAIN (t);
2823: if (t == NULL_TREE)
2824: CLEAR_BINFO_VBASE_MARKED (vbases);
2825: }
2826: }
2827:
2828: return ordered_vbase_types;
2829: }
2830:
2831: static void
2832: dfs_record_inheritance (binfo)
2833: tree binfo;
2834: {
2835: tree binfos = BINFO_BASETYPES (binfo);
2836: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2837: mi_boolean *derived_row = BINFO_DERIVES_FROM_STAR (binfo);
2838:
2839: for (i = n_baselinks-1; i >= 0; i--)
2840: {
2841: int j;
2842: tree base_binfo = TREE_VEC_ELT (binfos, i);
2843: tree baseclass = BINFO_TYPE (base_binfo);
2844: mi_boolean *base_row = BINFO_DERIVES_FROM_STAR (base_binfo);
2845:
2846: /* Don't search if there's nothing there! MI_SIZE can be
2847: zero as a result of parse errors. */
2848: if (TYPE_BINFO_BASETYPES (baseclass) && mi_size > 0)
2849: for (j = mi_size*(CLASSTYPE_CID (baseclass)-1); j >= 0; j -= mi_size)
2850: derived_row[j] |= base_row[j];
2851: TYPE_DERIVES_FROM (baseclass, BINFO_TYPE (binfo)) = 1;
2852: }
2853:
2854: SET_BINFO_MARKED (binfo);
2855: }
2856:
2857: /* Given a _CLASSTYPE node in a multiple inheritance lattice,
2858: convert the lattice into a simple relation such that,
2859: given to CIDs, C1 and C2, one can determine if C1 <= C2
2860: or C2 <= C1 or C1 <> C2.
2861:
2862: Once constructed, we walk the lattice depth fisrt,
2863: applying various functions to elements as they are encountered.
2864:
2865: We use xmalloc here, in case we want to randomly free these tables. */
2866:
2867: #define SAVE_MI_MATRIX
2868:
2869: void
2870: build_mi_matrix (type)
2871: tree type;
2872: {
2873: tree binfo = TYPE_BINFO (type);
2874: cid = 0;
2875:
2876: #ifdef SAVE_MI_MATRIX
2877: if (CLASSTYPE_MI_MATRIX (type))
2878: {
2879: mi_size = CLASSTYPE_N_SUPERCLASSES (type) + CLASSTYPE_N_VBASECLASSES (type);
2880: mi_matrix = CLASSTYPE_MI_MATRIX (type);
2881: mi_type = type;
2882: dfs_walk (binfo, dfs_number, unnumberedp);
2883: return;
2884: }
2885: #endif
2886:
2887: mi_size = CLASSTYPE_N_SUPERCLASSES (type) + CLASSTYPE_N_VBASECLASSES (type);
2888: mi_matrix = (char *)xmalloc ((mi_size + 1) * (mi_size + 1));
2889: mi_type = type;
2890: bzero (mi_matrix, (mi_size + 1) * (mi_size + 1));
2891: dfs_walk (binfo, dfs_number, unnumberedp);
2892: dfs_walk (binfo, dfs_record_inheritance, unmarkedp);
2893: dfs_walk (binfo, dfs_unmark, markedp);
2894: }
2895:
2896: void
2897: free_mi_matrix ()
2898: {
2899: dfs_walk (TYPE_BINFO (mi_type), dfs_unnumber, numberedp);
2900:
2901: #ifdef SAVE_MI_MATRIX
2902: CLASSTYPE_MI_MATRIX (mi_type) = mi_matrix;
2903: #else
2904: free (mi_matrix);
2905: mi_size = 0;
2906: cid = 0;
2907: #endif
2908: }
2909:
2910: /* Local variables for detecting ambiguities of virtual functions
2911: when two or more classes are joined at a multiple inheritance
2912: seam. */
2913: typedef struct {
2914: tree decl;
2915: tree args;
2916: tree ptr;
2917: } mi_ventry;
2918: static mi_ventry *mi_vmatrix;
2919: static int *mi_vmax;
2920: static int mi_vrows, mi_vcols;
2921: #define MI_VMATRIX(ROW,COL) ((mi_vmatrix + (ROW)*mi_vcols)[COL])
2922:
2923: /* Build a table of virtual functions for a multiple-inheritance
2924: structure. Here, there are N base classes, and at most
2925: M entries per class.
2926:
2927: This function does nothing if N is 0 or 1. */
2928: void
2929: build_mi_virtuals (rows, cols)
2930: int rows, cols;
2931: {
2932: if (rows < 2 || cols == 0)
2933: return;
2934: mi_vrows = rows;
2935: mi_vcols = cols;
2936: mi_vmatrix = (mi_ventry *)xmalloc ((rows+1) * cols * sizeof (mi_ventry));
2937: mi_vmax = (int *)xmalloc ((rows+1) * sizeof (int));
2938:
2939: bzero (mi_vmax, rows * sizeof (int));
2940:
2941: /* Row indices start at 1, so adjust this. */
2942: mi_vmatrix -= cols;
2943: mi_vmax -= 1;
2944: }
2945:
2946: /* Comparison function for ordering virtual function table entries. */
2947: static int
2948: rank_mi_virtuals (v1, v2)
2949: mi_ventry *v1, *v2;
2950: {
2951: tree p1, p2;
2952: int i;
2953:
2954: i = (long) (DECL_NAME (v1->decl)) - (long) (DECL_NAME (v2->decl));
2955: if (i)
2956: return i;
2957: p1 = v1->args;
2958: p2 = v2->args;
2959:
2960: if (p1 == p2)
2961: return 0;
2962:
2963: while (p1 && p2)
2964: {
2965: i = ((long) (TREE_VALUE (p1)) - (long) (TREE_VALUE (p2)));
2966: if (i)
2967: return i;
2968:
2969: if (TREE_CHAIN (p1))
2970: {
2971: if (! TREE_CHAIN (p2))
2972: return 1;
2973: p1 = TREE_CHAIN (p1);
2974: p2 = TREE_CHAIN (p2);
2975: }
2976: else if (TREE_CHAIN (p2))
2977: return -1;
2978: else
2979: {
2980: /* When matches of argument lists occur, pick lowest
2981: address to keep searching time to a minimum on
2982: later passes--like hashing, only different.
2983: *MUST BE STABLE*. */
2984: if ((long) (v2->args) < (long) (v1->args))
2985: v1->args = v2->args;
2986: else
2987: v2->args = v1->args;
2988: return 0;
2989: }
2990: }
2991: return 0;
2992: }
2993:
2994: /* Install the virtuals functions got from the initializer VIRTUALS to
2995: the table at index ROW. */
2996: void
2997: add_mi_virtuals (row, virtuals)
2998: int row;
2999: tree virtuals;
3000: {
3001: int col = 0;
3002:
3003: if (mi_vmatrix == 0)
3004: return;
3005: while (virtuals)
3006: {
3007: tree decl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
3008: MI_VMATRIX (row, col).decl = decl;
3009: MI_VMATRIX (row, col).args = FUNCTION_ARG_CHAIN (decl);
3010: MI_VMATRIX (row, col).ptr = TREE_VALUE (virtuals);
3011: virtuals = TREE_CHAIN (virtuals);
3012: col += 1;
3013: }
3014: mi_vmax[row] = col;
3015:
3016: qsort (mi_vmatrix + row * mi_vcols,
3017: col,
3018: sizeof (mi_ventry),
3019: rank_mi_virtuals);
3020: }
3021:
3022: /* If joining two types results in an ambiguity in the virtual
3023: function table, report such here. */
3024: void
3025: report_ambiguous_mi_virtuals (rows, type)
3026: int rows;
3027: tree type;
3028: {
3029: int *mi_vmin;
3030: int row1, col1, row, col;
3031:
3032: if (mi_vmatrix == 0)
3033: return;
3034:
3035: /* Now virtuals are all sorted, so we merge to find ambiguous cases. */
3036: mi_vmin = (int *)alloca ((rows+1) * sizeof (int));
3037: bzero (mi_vmin, rows * sizeof (int));
3038:
3039: /* adjust. */
3040: mi_vmin -= 1;
3041:
3042: /* For each base class with virtual functions (and this includes views
3043: of the virtual baseclasses from different base classes), see that
3044: each virtual function in that base class has a unique meet.
3045:
3046: When the column loop is finished, THIS_DECL is in fact the meet.
3047: If that value does not appear in the virtual function table for
3048: the row, install it. This happens when that virtual function comes
3049: from a virtual baseclass, or a non-leftmost baseclass. */
3050:
3051: for (row1 = 1; row1 < rows; row1++)
3052: {
3053: tree this_decl = 0;
3054:
3055: for (col1 = mi_vmax[row1]-1; col1 >= mi_vmin[row1]; col1--)
3056: {
3057: tree these_args = MI_VMATRIX (row1, col1).args;
3058: tree this_context;
3059:
3060: this_decl = MI_VMATRIX (row1, col1).decl;
3061: if (this_decl == 0)
3062: continue;
3063: this_context = TYPE_BINFO (DECL_CLASS_CONTEXT (this_decl));
3064:
3065: if (this_context != TYPE_BINFO (type))
3066: this_context = get_binfo (this_context, type, 0);
3067:
3068: for (row = row1+1; row <= rows; row++)
3069: for (col = mi_vmax[row]-1; col >= mi_vmin[row]; col--)
3070: {
3071: mi_ventry this_entry;
3072:
3073: if (MI_VMATRIX (row, col).decl == 0)
3074: continue;
3075:
3076: this_entry.decl = this_decl;
3077: this_entry.args = these_args;
3078: this_entry.ptr = MI_VMATRIX (row1, col1).ptr;
3079: if (rank_mi_virtuals (&this_entry, &MI_VMATRIX (row, col)) == 0)
3080: {
3081: /* They are equal. There are four possibilities:
3082:
3083: (1) Derived class is defining this virtual function.
3084: (2) Two paths to the same virtual function in the
3085: same base class.
3086: (3) A path to a virtual function declared in one base
3087: class, and another path to a virtual function in a
3088: base class of the base class.
3089: (4) Two paths to the same virtual function in different
3090: base classes.
3091:
3092: The first three cases are ok (non-ambiguous). */
3093:
3094: tree that_context, tmp;
3095: int this_before_that;
3096:
3097: if (type == BINFO_TYPE (this_context))
3098: /* case 1. */
3099: goto ok;
3100: that_context = get_binfo (DECL_CLASS_CONTEXT (MI_VMATRIX (row, col).decl), type, 0);
3101: if (that_context == this_context)
3102: /* case 2. */
3103: goto ok;
3104: if (that_context != NULL_TREE)
3105: {
3106: tmp = get_binfo (that_context, this_context, 0);
3107: this_before_that = (that_context != tmp);
3108: if (this_before_that == 0)
3109: /* case 3a. */
3110: goto ok;
3111: tmp = get_binfo (this_context, that_context, 0);
3112: this_before_that = (this_context == tmp);
3113: if (this_before_that != 0)
3114: /* case 3b. */
3115: goto ok;
3116:
3117: /* case 4. */
3118: /* These two are not hard errors, but could be
3119: symptoms of bad code. The resultant code
3120: the compiler generates needs to be checked.
3121: (mrs) */
3122: #if 0
3123: cp_error_at ("ambiguous virtual function `%s'",
3124: MI_VMATRIX (row, col).decl);
3125: cp_error_at ("ambiguating function `%D' (joined by type `%T')", this_decl, current_class_name);
3126: #endif
3127: }
3128: ok:
3129: MI_VMATRIX (row, col).decl = 0;
3130:
3131: /* Let zeros propagate. */
3132: if (col == mi_vmax[row]-1)
3133: {
3134: int i = col;
3135: while (i >= mi_vmin[row]
3136: && MI_VMATRIX (row, i).decl == 0)
3137: i--;
3138: mi_vmax[row] = i+1;
3139: }
3140: else if (col == mi_vmin[row])
3141: {
3142: int i = col;
3143: while (i < mi_vmax[row]
3144: && MI_VMATRIX (row, i).decl == 0)
3145: i++;
3146: mi_vmin[row] = i;
3147: }
3148: }
3149: }
3150: }
3151: }
3152: free (mi_vmatrix + mi_vcols);
3153: mi_vmatrix = 0;
3154: free (mi_vmax + 1);
3155: mi_vmax = 0;
3156: }
3157:
3158: /* If we want debug info for a type TYPE, make sure all its base types
3159: are also marked as being potentially interesting. This avoids
3160: the problem of not writing any debug info for intermediate basetypes
3161: that have abstract virtual functions. */
3162:
3163: void
3164: note_debug_info_needed (type)
3165: tree type;
3166: {
3167: dfs_walk (TYPE_BINFO (type), dfs_debug_mark, dfs_debug_unmarkedp);
3168: }
3169:
3170: /* Subroutines of push_class_decls (). */
3171:
3172: /* Add the instance variables which this class contributed to the
3173: current class binding contour. When a redefinition occurs,
3174: if the redefinition is strictly within a single inheritance path,
3175: we just overwrite (in the case of a data field) or
3176: cons (in the case of a member function) the old declaration with
3177: the new. If the fields are not within a single inheritance path,
3178: we must cons them in either case.
3179:
3180: when NEW_CLASS_SCOPING is 1:
3181:
3182: In order to know what decls are new (stemming from the current
3183: invocation of push_class_decls) we enclose them in an "envelope",
3184: which is a TREE_LIST node where the TREE_PURPOSE slot contains the
3185: new decl (or possibly a list of competing ones), the TREE_VALUE slot
3186: points to the old value and the TREE_CHAIN slot chains together all
3187: envelopes which needs to be "opened" in push_class_decls. Opening an
3188: envelope means: push the old value onto the class_shadowed list,
3189: install the new one and if it's a TYPE_DECL do the same to the
3190: IDENTIFIER_TYPE_VALUE. Such an envelope is recognized by seeing that
3191: the TREE_PURPOSE slot is non-null, and that it is not an identifier.
3192: Because if it is, it could be a set of overloaded methods from an
3193: outer scope. */
3194:
3195: static void
3196: dfs_pushdecls (binfo)
3197: tree binfo;
3198: {
3199: tree type = BINFO_TYPE (binfo);
3200: tree fields, *methods, *end;
3201: tree method_vec;
3202:
3203: for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
3204: {
3205: /* Unmark so that if we are in a constructor, and then find that
3206: this field was initialized by a base initializer,
3207: we can emit an error message. */
3208: if (TREE_CODE (fields) == FIELD_DECL)
3209: TREE_USED (fields) = 0;
3210:
3211: /* Recurse into anonymous unions. */
3212: if (DECL_NAME (fields) == NULL_TREE
3213: && TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
3214: {
3215: dfs_pushdecls (TYPE_BINFO (TREE_TYPE (fields)));
3216: continue;
3217: }
3218:
3219: if (TREE_CODE (fields) != TYPE_DECL)
3220: {
3221: DECL_PUBLIC (fields) = 0;
3222: DECL_PROTECTED (fields) = 0;
3223: DECL_PRIVATE (fields) = 0;
3224: }
3225:
3226: if (DECL_NAME (fields))
3227: {
3228: #if NEW_CLASS_SCOPING
3229: tree class_value = IDENTIFIER_CLASS_VALUE (DECL_NAME (fields));
3230:
3231: /* If the class value is an envelope of the kind described in
3232: the comment above, we try to rule out possible ambiguities.
3233: If we can't do that, keep a TREE_LIST with possibly ambiguous
3234: decls in there. */
3235: if (class_value && TREE_CODE (class_value) == TREE_LIST
3236: && TREE_PURPOSE (class_value) != NULL_TREE
3237: && (TREE_CODE (TREE_PURPOSE (class_value))
3238: != IDENTIFIER_NODE))
3239: {
3240: tree value = TREE_PURPOSE (class_value);
3241: #else
3242: tree value = IDENTIFIER_CLASS_VALUE (DECL_NAME (fields));
3243: if (value)
3244: {
3245: #endif
3246: tree context;
3247:
3248: /* Possible ambiguity. If its defining type(s)
3249: is (are all) derived from us, no problem. */
3250: if (TREE_CODE (value) != TREE_LIST)
3251: {
3252: context = (TREE_CODE (value) == FUNCTION_DECL
3253: && DECL_VIRTUAL_P (value))
3254: ? DECL_CLASS_CONTEXT (value)
3255: : DECL_CONTEXT (value);
3256:
3257: if (context && (context == type
3258: || TYPE_DERIVES_FROM (context, type)))
3259: value = fields;
3260: else
3261: value = tree_cons (NULL_TREE, fields,
3262: build_tree_list (NULL_TREE, value));
3263: }
3264: else
3265: {
3266: /* All children may derive from us, in which case
3267: there is no problem. Otherwise, we have to
3268: keep lists around of what the ambiguities might be. */
3269: tree values;
3270: int problem = 0;
3271:
3272: for (values = value; values; values = TREE_CHAIN (values))
3273: {
3274: tree sub_values = TREE_VALUE (values);
3275:
3276: if (TREE_CODE (sub_values) == TREE_LIST)
3277: {
3278: for (; sub_values; sub_values = TREE_CHAIN (sub_values))
3279: {
3280: register tree list_mbr = TREE_VALUE (sub_values);
3281:
3282: context = (TREE_CODE (list_mbr) == FUNCTION_DECL
3283: && DECL_VIRTUAL_P (list_mbr))
3284: ? DECL_CLASS_CONTEXT (list_mbr)
3285: : DECL_CONTEXT (list_mbr);
3286:
3287: if (! TYPE_DERIVES_FROM (context, type))
3288: {
3289: value = tree_cons (NULL_TREE, TREE_VALUE (values), value);
3290: problem = 1;
3291: break;
3292: }
3293: }
3294: }
3295: else
3296: {
3297: context = (TREE_CODE (sub_values) == FUNCTION_DECL
3298: && DECL_VIRTUAL_P (sub_values))
3299: ? DECL_CLASS_CONTEXT (sub_values)
3300: : DECL_CONTEXT (sub_values);
3301:
3302: if (context && ! TYPE_DERIVES_FROM (context, type))
3303: {
3304: value = tree_cons (NULL_TREE, values, value);
3305: problem = 1;
3306: break;
3307: }
3308: }
3309: }
3310: if (! problem) value = fields;
3311: }
3312:
3313: /* Mark this as a potentially ambiguous member. */
3314: if (TREE_CODE (value) == TREE_LIST)
3315: {
3316: /* Leaving TREE_TYPE blank is intentional.
3317: We cannot use `error_mark_node' (lookup_name)
3318: or `unknown_type_node' (all member functions use this). */
3319: TREE_NONLOCAL_FLAG (value) = 1;
3320: }
3321:
3322: #if NEW_CLASS_SCOPING
3323: /* Put the new contents in our envelope. */
3324: TREE_PURPOSE (class_value) = value;
3325: }
3326: else
3327: {
3328: /* See comment above for a description of envelopes. */
3329: tree envelope = tree_cons (fields, class_value,
3330: closed_envelopes);
3331:
3332: closed_envelopes = envelope;
3333: IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = envelope;
3334: }
3335: #else
3336: IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = value;
3337: }
3338: else IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = fields;
3339: #endif
3340: }
3341: }
3342:
3343: method_vec = CLASSTYPE_METHOD_VEC (type);
3344: if (method_vec != 0)
3345: {
3346: /* Farm out constructors and destructors. */
3347: methods = &TREE_VEC_ELT (method_vec, 1);
3348: end = TREE_VEC_END (method_vec);
3349:
3350: /* This does not work for multiple inheritance yet. */
3351: while (methods != end)
3352: {
3353: /* This will cause lookup_name to return a pointer
3354: to the tree_list of possible methods of this name.
3355: If the order is a problem, we can nreverse them. */
3356: tree tmp;
3357: #if NEW_CLASS_SCOPING
3358: tree class_value = IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods));
3359:
3360: if (class_value && TREE_CODE (class_value) == TREE_LIST
3361: && TREE_PURPOSE (class_value) != NULL_TREE
3362: && TREE_CODE (TREE_PURPOSE (class_value)) != IDENTIFIER_NODE)
3363: {
3364: tree old = TREE_PURPOSE (class_value);
3365:
3366: maybe_push_cache_obstack ();
3367: if (TREE_CODE (old) == TREE_LIST)
3368: tmp = tree_cons (DECL_NAME (*methods), *methods, old);
3369: else
3370: {
3371: /* Only complain if we shadow something we can access. */
3372: if (old
3373: && ((DECL_LANG_SPECIFIC (old)
3374: && DECL_CLASS_CONTEXT (old) == current_class_type)
3375: || ! TREE_PRIVATE (old)))
3376: /* Should figure out visibility more accurately. */
3377: cp_warning ("shadowing member `%#D' with member function `%#D'",
3378: old, *methods);
3379: tmp = build_tree_list (DECL_NAME (*methods), *methods);
3380: }
3381: pop_obstacks ();
3382:
3383: TREE_TYPE (tmp) = unknown_type_node;
3384: #if 0
3385: TREE_OVERLOADED (tmp) = DECL_OVERLOADED (*methods);
3386: #endif
3387: TREE_NONLOCAL_FLAG (tmp) = 1;
3388:
3389: /* Put the new contents in our envelope. */
3390: TREE_PURPOSE (class_value) = tmp;
3391: }
3392: else
3393: {
3394: maybe_push_cache_obstack ();
3395: tmp = build_tree_list (DECL_NAME (*methods), *methods);
3396: pop_obstacks ();
3397:
3398: TREE_TYPE (tmp) = unknown_type_node;
3399: #if 0
3400: TREE_OVERLOADED (tmp) = DECL_OVERLOADED (*methods);
3401: #endif
3402: TREE_NONLOCAL_FLAG (tmp) = 1;
3403:
3404: /* See comment above for a description of envelopes. */
3405: closed_envelopes = tree_cons (tmp, class_value,
3406: closed_envelopes);
3407: IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = closed_envelopes;
3408: }
3409: #else
3410: tree old = IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods));
3411:
3412: if (old && TREE_CODE (old) == TREE_LIST)
3413: tmp = tree_cons (DECL_NAME (*methods), *methods, old);
3414: else
3415: {
3416: /* Only complain if we shadow something we can access. */
3417: if (old && (DECL_CLASS_CONTEXT (old) == current_class_type
3418: || ! TREE_PRIVATE (old)))
3419: /* Should figure out visibility more accurately. */
3420: cp_warning_at ("member function `%D' shadows member `%s'", *methods,
3421: IDENTIFIER_POINTER (DECL_NAME (old)));
3422: tmp = build_tree_list (DECL_NAME (*methods), *methods);
3423: }
3424:
3425: TREE_TYPE (tmp) = unknown_type_node;
3426: #if 0
3427: TREE_OVERLOADED (tmp) = DECL_OVERLOADED (*methods);
3428: #endif
3429: TREE_NONLOCAL_FLAG (tmp) = 1;
3430: IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = tmp;
3431: #endif
3432:
3433: tmp = *methods;
3434: while (tmp != 0)
3435: {
3436: DECL_PUBLIC (tmp) = 0;
3437: DECL_PROTECTED (tmp) = 0;
3438: DECL_PRIVATE (tmp) = 0;
3439: tmp = DECL_CHAIN (tmp);
3440: }
3441:
3442: methods++;
3443: }
3444: }
3445: SET_BINFO_MARKED (binfo);
3446: }
3447:
3448: /* Consolidate unique (by name) member functions. */
3449: static void
3450: dfs_compress_decls (binfo)
3451: tree binfo;
3452: {
3453: tree type = BINFO_TYPE (binfo);
3454: tree method_vec = CLASSTYPE_METHOD_VEC (type);
3455:
3456: if (method_vec != 0)
3457: {
3458: /* Farm out constructors and destructors. */
3459: tree *methods = &TREE_VEC_ELT (method_vec, 1);
3460: tree *end = TREE_VEC_END (method_vec);
3461:
3462: for (; methods != end; methods++)
3463: {
3464: #if NEW_CLASS_SCOPING
3465: /* This is known to be an envelope of the kind described before
3466: dfs_pushdecls. */
3467: tree class_value = IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods));
3468: tree tmp = TREE_PURPOSE (class_value);
3469: #else
3470: tree tmp = IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods));
3471: #endif
3472:
3473: /* This was replaced in scope by somebody else. Just leave it
3474: alone. */
3475: if (TREE_CODE (tmp) != TREE_LIST)
3476: continue;
3477:
3478: if (TREE_CHAIN (tmp) == NULL_TREE
3479: && TREE_VALUE (tmp)
3480: && DECL_CHAIN (TREE_VALUE (tmp)) == NULL_TREE)
3481: {
3482: #if NEW_CLASS_SCOPING
3483: TREE_PURPOSE (class_value) = TREE_VALUE (tmp);
3484: #else
3485: IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = TREE_VALUE (tmp);
3486: #endif
3487: }
3488: }
3489: }
3490: CLEAR_BINFO_MARKED (binfo);
3491: }
3492:
3493: /* When entering the scope of a class, we cache all of the
3494: fields that that class provides within its inheritance
3495: lattice. Where ambiguities result, we mark them
3496: with `error_mark_node' so that if they are encountered
3497: without explicit qualification, we can emit an error
3498: message. */
3499: void
3500: push_class_decls (type)
3501: tree type;
3502: {
3503: tree id;
3504: struct obstack *ambient_obstack = current_obstack;
3505:
3506: #if 0
3507: tree tags = CLASSTYPE_TAGS (type);
3508:
3509: while (tags)
3510: {
3511: tree code_type_node;
3512: tree tag;
3513:
3514: switch (TREE_CODE (TREE_VALUE (tags)))
3515: {
3516: case ENUMERAL_TYPE:
3517: code_type_node = enum_type_node;
3518: break;
3519: case RECORD_TYPE:
3520: code_type_node = record_type_node;
3521: break;
3522: case CLASS_TYPE:
3523: code_type_node = class_type_node;
3524: break;
3525: case UNION_TYPE:
3526: code_type_node = union_type_node;
3527: break;
3528: default:
3529: my_friendly_abort (297);
3530: }
3531: tag = xref_tag (code_type_node, TREE_PURPOSE (tags),
3532: TYPE_BINFO_BASETYPE (TREE_VALUE (tags), 0));
3533: #if 0 /* not yet, should get fixed properly later */
3534: pushdecl (make_type_decl (TREE_PURPOSE (tags), TREE_VALUE (tags)));
3535: #else
3536: pushdecl (build_decl (TYPE_DECL, TREE_PURPOSE (tags), TREE_VALUE (tags)));
3537: #endif
3538: }
3539: #endif
3540:
3541: search_stack = push_search_level (search_stack, &search_obstack);
3542:
3543: id = TYPE_IDENTIFIER (type);
3544: if (IDENTIFIER_TEMPLATE (id) != 0)
3545: {
3546: #if 0
3547: tree tmpl = IDENTIFIER_TEMPLATE (id);
3548: push_template_decls (DECL_ARGUMENTS (TREE_PURPOSE (tmpl)),
3549: TREE_VALUE (tmpl), 1);
3550: #endif
3551: #if NEW_CLASS_SCOPING
3552: overload_template_name (id, 1);
3553: #else
3554: overload_template_name (id, 0);
3555: #endif
3556: }
3557:
3558: /* Push class fields into CLASS_VALUE scope, and mark. */
3559: dfs_walk (TYPE_BINFO (type), dfs_pushdecls, unmarkedp);
3560:
3561: /* Compress fields which have only a single entry
3562: by a given name, and unmark. */
3563: dfs_walk (TYPE_BINFO (type), dfs_compress_decls, markedp);
3564:
3565: #if NEW_CLASS_SCOPING
3566: /* Open up all the closed envelopes and push the contained decls into
3567: class scope. */
3568: while (closed_envelopes)
3569: {
3570: tree new = TREE_PURPOSE (closed_envelopes);
3571: tree id;
3572:
3573: /* This is messy because the class value may be a *_DECL, or a
3574: TREE_LIST of overloaded *_DECLs or even a TREE_LIST of ambiguous
3575: *_DECLs. The name is stored at different places in these three
3576: cases. */
3577: if (TREE_CODE (new) == TREE_LIST)
3578: {
3579: if (TREE_PURPOSE (new) != NULL_TREE)
3580: id = TREE_PURPOSE (new);
3581: else
3582: {
3583: tree node = TREE_VALUE (new);
3584:
3585: while (TREE_CODE (node) == TREE_LIST)
3586: node = TREE_VALUE (node);
3587: id = DECL_NAME (node);
3588: }
3589: }
3590: else
3591: id = DECL_NAME (new);
3592:
3593: /* Install the original class value in order to make
3594: pushdecl_class_level work correctly. */
3595: IDENTIFIER_CLASS_VALUE (id) = TREE_VALUE (closed_envelopes);
3596: if (TREE_CODE (new) == TREE_LIST)
3597: push_class_level_binding (id, new);
3598: else
3599: pushdecl_class_level (new);
3600: closed_envelopes = TREE_CHAIN (closed_envelopes);
3601: }
3602: #endif
3603: current_obstack = ambient_obstack;
3604: }
3605:
3606: #if !NEW_CLASS_SCOPING
3607: static void
3608: dfs_popdecls (binfo)
3609: tree binfo;
3610: {
3611: tree type = BINFO_TYPE (binfo);
3612: tree fields = TYPE_FIELDS (type);
3613: tree method_vec = CLASSTYPE_METHOD_VEC (type);
3614:
3615: while (fields)
3616: {
3617: if (DECL_NAME (fields) == NULL_TREE
3618: && TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
3619: {
3620: dfs_popdecls (TYPE_BINFO (TREE_TYPE (fields)));
3621: }
3622: else if (DECL_NAME (fields))
3623: IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = NULL_TREE;
3624: fields = TREE_CHAIN (fields);
3625: }
3626: if (method_vec != 0)
3627: {
3628: tree *methods = &TREE_VEC_ELT (method_vec, 0);
3629: tree *end = TREE_VEC_END (method_vec);
3630:
3631: /* Clear out ctors and dtors. */
3632: if (*methods)
3633: IDENTIFIER_CLASS_VALUE (TYPE_IDENTIFIER (type)) = NULL_TREE;
3634:
3635: for (methods += 1; methods != end; methods++)
3636: IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = NULL_TREE;
3637: }
3638:
3639: SET_BINFO_MARKED (binfo);
3640: }
3641: #endif
3642:
3643: void
3644: pop_class_decls (type)
3645: tree type;
3646: {
3647: #if !NEW_CLASS_SCOPING
3648: tree binfo = TYPE_BINFO (type);
3649:
3650: /* Clear out the IDENTIFIER_CLASS_VALUE which this
3651: class may have occupied, and mark. */
3652: dfs_walk (binfo, dfs_popdecls, unmarkedp);
3653:
3654: /* Unmark. */
3655: dfs_walk (binfo, dfs_unmark, markedp);
3656: #else
3657: /* We haven't pushed a search level when dealing with cached classes,
3658: so we'd better not try to pop it. */
3659: if (search_stack)
3660: #endif
3661: search_stack = pop_search_level (search_stack);
3662: }
3663:
3664: static int
3665: bfs_unmark_finished_struct (binfo, i)
3666: tree binfo;
3667: int i;
3668: {
3669: if (i >= 0)
3670: binfo = BINFO_BASETYPE (binfo, i);
3671:
3672: if (BINFO_NEW_VTABLE_MARKED (binfo))
3673: {
3674: tree decl, context;
3675:
3676: if (TREE_VIA_VIRTUAL (binfo))
3677: binfo = binfo_member (BINFO_TYPE (binfo),
3678: CLASSTYPE_VBASECLASSES (current_class_type));
3679:
3680: decl = BINFO_VTABLE (binfo);
3681: context = DECL_CONTEXT (decl);
3682: DECL_CONTEXT (decl) = 0;
3683: if (write_virtuals >= 0
3684: && DECL_INITIAL (decl) != BINFO_VIRTUALS (binfo))
3685: DECL_INITIAL (decl) = build_nt (CONSTRUCTOR, NULL_TREE,
3686: BINFO_VIRTUALS (binfo));
3687: finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0);
3688: DECL_CONTEXT (decl) = context;
3689: }
3690: CLEAR_BINFO_VTABLE_PATH_MARKED (binfo);
3691: CLEAR_BINFO_NEW_VTABLE_MARKED (binfo);
3692: return 0;
3693: }
3694:
3695: void
3696: unmark_finished_struct (type)
3697: tree type;
3698: {
3699: tree binfo = TYPE_BINFO (type);
3700: bfs_unmark_finished_struct (binfo, -1);
3701: breadth_first_search (binfo, bfs_unmark_finished_struct, bfs_marked_vtable_pathp);
3702: }
3703:
3704: void
3705: print_search_statistics ()
3706: {
3707: #ifdef GATHER_STATISTICS
3708: if (flag_memoize_lookups)
3709: {
3710: fprintf (stderr, "%d memoized contexts saved\n",
3711: n_contexts_saved);
3712: fprintf (stderr, "%d local tree nodes made\n", my_tree_node_counter);
3713: fprintf (stderr, "%d local hash nodes made\n", my_memoized_entry_counter);
3714: fprintf (stderr, "fields statistics:\n");
3715: fprintf (stderr, " memoized finds = %d; rejects = %d; (searches = %d)\n",
3716: memoized_fast_finds[0], memoized_fast_rejects[0],
3717: memoized_fields_searched[0]);
3718: fprintf (stderr, " memoized_adds = %d\n", memoized_adds[0]);
3719: fprintf (stderr, "fnfields statistics:\n");
3720: fprintf (stderr, " memoized finds = %d; rejects = %d; (searches = %d)\n",
3721: memoized_fast_finds[1], memoized_fast_rejects[1],
3722: memoized_fields_searched[1]);
3723: fprintf (stderr, " memoized_adds = %d\n", memoized_adds[1]);
3724: }
3725: fprintf (stderr, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
3726: n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1);
3727: fprintf (stderr, "%d fnfields searched in %d calls to lookup_fnfields\n",
3728: n_outer_fields_searched, n_calls_lookup_fnfields);
3729: fprintf (stderr, "%d calls to get_base_type\n", n_calls_get_base_type);
3730: #else
3731: fprintf (stderr, "no search statistics\n");
3732: #endif
3733: }
3734:
3735: void
3736: init_search_processing ()
3737: {
3738: gcc_obstack_init (&search_obstack);
3739: gcc_obstack_init (&type_obstack);
3740: gcc_obstack_init (&type_obstack_entries);
3741:
3742: /* This gives us room to build our chains of basetypes,
3743: whether or not we decide to memoize them. */
3744: type_stack = push_type_level (0, &type_obstack);
3745: _vptr_name = get_identifier ("_vptr");
3746: }
3747:
3748: void
3749: reinit_search_statistics ()
3750: {
3751: my_memoized_entry_counter = 0;
3752: memoized_fast_finds[0] = 0;
3753: memoized_fast_finds[1] = 0;
3754: memoized_adds[0] = 0;
3755: memoized_adds[1] = 0;
3756: memoized_fast_rejects[0] = 0;
3757: memoized_fast_rejects[1] = 0;
3758: memoized_fields_searched[0] = 0;
3759: memoized_fields_searched[1] = 0;
3760: n_fields_searched = 0;
3761: n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0;
3762: n_calls_lookup_fnfields = 0, n_calls_lookup_fnfields_1 = 0;
3763: n_calls_get_base_type = 0;
3764: n_outer_fields_searched = 0;
3765: n_contexts_saved = 0;
3766: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.