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