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