diff options
Diffstat (limited to 'gnu/gcc2/cc1plus/cp-search.c')
| -rw-r--r-- | gnu/gcc2/cc1plus/cp-search.c | 4284 |
1 files changed, 0 insertions, 4284 deletions
diff --git a/gnu/gcc2/cc1plus/cp-search.c b/gnu/gcc2/cc1plus/cp-search.c deleted file mode 100644 index 9f3e0a5a1549..000000000000 --- a/gnu/gcc2/cc1plus/cp-search.c +++ /dev/null @@ -1,4284 +0,0 @@ -/* Breadth-first and depth-first routines for - searching multiple-inheritance lattice for GNU C++. - Copyright (C) 1987, 1989, 1992, 1993 Free Software Foundation, Inc. - Contributed by Michael Tiemann (tiemann@cygnus.com) - -This file is part of GNU CC. - -GNU CC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. - -GNU CC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ - -#if 0 -/* Remove before release, should only appear for development and testing. */ -#define CHECK_convert_pointer_to_single_level -#endif - -/* High-level class interface. */ - -#include "config.h" -#include "tree.h" -#include <stdio.h> -#include "cp-tree.h" -#include "obstack.h" -#include "flags.h" - -#define obstack_chunk_alloc xmalloc -#define obstack_chunk_free free - -void init_search (); -extern struct obstack *current_obstack; - -#include "stack.h" - -/* Obstack used for remembering decision points of breadth-first. */ -static struct obstack search_obstack; - -/* Obstack used to bridge from one function context to another. */ -static struct obstack bridge_obstack; - -/* Methods for pushing and popping objects to and from obstacks. */ - -struct stack_level * -push_stack_level (obstack, tp, size) - struct obstack *obstack; - char *tp; /* Sony NewsOS 5.0 compiler doesn't like void * here. */ - int size; -{ - struct stack_level *stack; - /* FIXME. Doesn't obstack_grow, in the case when the current chunk has - insufficient space, move the base so that obstack_next_free is not - valid? Perhaps obstack_copy should be used rather than obstack_grow, - and its returned value be used. -- Raeburn - */ - stack = (struct stack_level *) obstack_next_free (obstack); - obstack_grow (obstack, tp, size); - obstack_finish (obstack); - stack->obstack = obstack; - stack->first = (tree *) obstack_base (obstack); - stack->limit = obstack_room (obstack) / sizeof (tree *); - return stack; -} - -struct stack_level * -pop_stack_level (stack) - struct stack_level *stack; -{ - struct stack_level *tem = stack; - struct obstack *obstack = tem->obstack; - stack = tem->prev; - obstack_free (obstack, tem); - return stack; -} - -#define search_level stack_level -static struct search_level *search_stack; - -static tree lookup_field_1 (); -static int lookup_fnfields_1 (); -static void dfs_walk (); -static int markedp (); -static void dfs_unmark (); -static void dfs_init_vbase_pointers (); - -static tree vbase_types; -static tree vbase_decl, vbase_decl_ptr; -static tree vbase_decl_ptr_intermediate; -static tree vbase_init_result; - -/* Allocate a level of searching. */ -static struct search_level * -push_search_level (stack, obstack) - struct stack_level *stack; - struct obstack *obstack; -{ - struct search_level tem; - tem.prev = stack; - - return push_stack_level (obstack, (char *) &tem, sizeof (tem)); -} - -/* Discard a level of search allocation. */ -#define pop_search_level pop_stack_level - -/* Search memoization. */ -struct type_level -{ - struct stack_level base; - - /* First object allocated in obstack of entries. */ - char *entries; - - /* Number of types memoized in this context. */ - int len; - - /* Type being memoized; save this if we are saving - memoized contexts. */ - tree type; -}; - -/* Obstack used for memoizing member and member function lookup. */ - -static struct obstack type_obstack, type_obstack_entries; -static struct type_level *type_stack; -static tree _vptr_name; - -/* Make things that look like tree nodes, but allocate them - on type_obstack_entries. */ -static int my_tree_node_counter; -static tree my_tree_cons (), my_build_string (); - -extern int flag_memoize_lookups, flag_save_memoized_contexts; - -/* Variables for gathering statistics. */ -static int my_memoized_entry_counter; -static int memoized_fast_finds[2], memoized_adds[2], memoized_fast_rejects[2]; -static int memoized_fields_searched[2]; -static int n_fields_searched; -static int n_calls_lookup_field, n_calls_lookup_field_1; -static int n_calls_lookup_fnfields, n_calls_lookup_fnfields_1; -static int n_calls_get_base_type; -static int n_outer_fields_searched; -static int n_contexts_saved; - -/* Local variables to help save memoization contexts. */ -static tree prev_type_memoized; -static struct type_level *prev_type_stack; - -/* Allocate a level of type memoization context. */ -static struct type_level * -push_type_level (stack, obstack) - struct stack_level *stack; - struct obstack *obstack; -{ - struct type_level tem; - - tem.base.prev = stack; - - obstack_finish (&type_obstack_entries); - tem.entries = (char *) obstack_base (&type_obstack_entries); - tem.len = 0; - tem.type = NULL_TREE; - - return (struct type_level *)push_stack_level (obstack, (char *) &tem, - sizeof (tem)); -} - -/* Discard a level of type memoization context. */ - -static struct type_level * -pop_type_level (stack) - struct type_level *stack; -{ - obstack_free (&type_obstack_entries, stack->entries); - return (struct type_level *)pop_stack_level ((struct stack_level *)stack); -} - -/* Make something that looks like a TREE_LIST, but - do it on the type_obstack_entries obstack. */ -static tree -my_tree_cons (purpose, value, chain) - tree purpose, value, chain; -{ - tree p = (tree)obstack_alloc (&type_obstack_entries, sizeof (struct tree_list)); - ++my_tree_node_counter; - TREE_TYPE (p) = NULL_TREE; - ((HOST_WIDE_INT *)p)[3] = 0; - TREE_SET_CODE (p, TREE_LIST); - TREE_PURPOSE (p) = purpose; - TREE_VALUE (p) = value; - TREE_CHAIN (p) = chain; - return p; -} - -static tree -my_build_string (str) - char *str; -{ - tree p = (tree)obstack_alloc (&type_obstack_entries, sizeof (struct tree_string)); - ++my_tree_node_counter; - TREE_TYPE (p) = 0; - ((int *)p)[3] = 0; - TREE_SET_CODE (p, STRING_CST); - TREE_STRING_POINTER (p) = str; - TREE_STRING_LENGTH (p) = strlen (str); - return p; -} - -/* Memoizing machinery to make searches for multiple inheritance - reasonably efficient. */ -#define MEMOIZE_HASHSIZE 8 -typedef struct memoized_entry -{ - struct memoized_entry *chain; - int uid; - tree data_members[MEMOIZE_HASHSIZE]; - tree function_members[MEMOIZE_HASHSIZE]; -} *ME; - -#define MEMOIZED_CHAIN(ENTRY) (((ME)ENTRY)->chain) -#define MEMOIZED_UID(ENTRY) (((ME)ENTRY)->uid) -#define MEMOIZED_FIELDS(ENTRY,INDEX) (((ME)ENTRY)->data_members[INDEX]) -#define MEMOIZED_FNFIELDS(ENTRY,INDEX) (((ME)ENTRY)->function_members[INDEX]) -/* The following is probably a lousy hash function. */ -#define MEMOIZED_HASH_FN(NODE) (((long)(NODE)>>4)&(MEMOIZE_HASHSIZE - 1)) - -static struct memoized_entry * -my_new_memoized_entry (chain) - struct memoized_entry *chain; -{ - struct memoized_entry *p = - (struct memoized_entry *)obstack_alloc (&type_obstack_entries, - sizeof (struct memoized_entry)); - bzero (p, sizeof (struct memoized_entry)); - MEMOIZED_CHAIN (p) = chain; - MEMOIZED_UID (p) = ++my_memoized_entry_counter; - return p; -} - -/* Make an entry in the memoized table for type TYPE - that the entry for NAME is FIELD. */ - -tree -make_memoized_table_entry (type, name, function_p) - tree type, name; - int function_p; -{ - int index = MEMOIZED_HASH_FN (name); - tree entry, *prev_entry; - - memoized_adds[function_p] += 1; - if (CLASSTYPE_MTABLE_ENTRY (type) == 0) - { - obstack_ptr_grow (&type_obstack, type); - obstack_blank (&type_obstack, sizeof (struct memoized_entry *)); - CLASSTYPE_MTABLE_ENTRY (type) = (char *)my_new_memoized_entry ((struct memoized_entry *)0); - type_stack->len++; - if (type_stack->len * 2 >= type_stack->base.limit) - my_friendly_abort (88); - } - if (function_p) - prev_entry = &MEMOIZED_FNFIELDS (CLASSTYPE_MTABLE_ENTRY (type), index); - else - prev_entry = &MEMOIZED_FIELDS (CLASSTYPE_MTABLE_ENTRY (type), index); - - entry = my_tree_cons (name, NULL_TREE, *prev_entry); - *prev_entry = entry; - - /* Don't know the error message to give yet. */ - TREE_TYPE (entry) = error_mark_node; - - return entry; -} - -/* When a new function or class context is entered, we build - a table of types which have been searched for members. - The table is an array (obstack) of types. When a type is - entered into the obstack, its CLASSTYPE_MTABLE_ENTRY - field is set to point to a new record, of type struct memoized_entry. - - A non-NULL TREE_TYPE of the entry contains a visibility error message. - - The slots for the data members are arrays of tree nodes. - These tree nodes are lists, with the TREE_PURPOSE - of this list the known member name, and the TREE_VALUE - as the FIELD_DECL for the member. - - For member functions, the TREE_PURPOSE is again the - name of the member functions for that class, - and the TREE_VALUE of the list is a pairs - whose TREE_PURPOSE is a member functions of this name, - and whose TREE_VALUE is a list of known argument lists this - member function has been called with. The TREE_TYPE of the pair, - if non-NULL, is an error message to print. */ - -/* Tell search machinery that we are entering a new context, and - to update tables appropriately. - - TYPE is the type of the context we are entering, which can - be NULL_TREE if we are not in a class's scope. - - USE_OLD, if nonzero tries to use previous context. */ -void -push_memoized_context (type, use_old) - tree type; - int use_old; -{ - int len; - tree *tem; - - if (prev_type_stack) - { - if (use_old && prev_type_memoized == type) - { -#ifdef GATHER_STATISTICS - n_contexts_saved++; -#endif - type_stack = prev_type_stack; - prev_type_stack = 0; - - tem = &type_stack->base.first[0]; - len = type_stack->len; - while (len--) - CLASSTYPE_MTABLE_ENTRY (tem[len*2]) = (char *)tem[len*2+1]; - return; - } - /* Otherwise, need to pop old stack here. */ - type_stack = pop_type_level (prev_type_stack); - prev_type_memoized = 0; - prev_type_stack = 0; - } - - type_stack = push_type_level ((struct stack_level *)type_stack, - &type_obstack); - type_stack->type = type; -} - -/* Tell search machinery that we have left a context. - We do not currently save these contexts for later use. - If we wanted to, we could not use pop_search_level, since - poping that level allows the data we have collected to - be clobbered; a stack of obstacks would be needed. */ -void -pop_memoized_context (use_old) - int use_old; -{ - int len; - tree *tem = &type_stack->base.first[0]; - - if (! flag_save_memoized_contexts) - use_old = 0; - else if (use_old) - { - len = type_stack->len; - while (len--) - tem[len*2+1] = (tree)CLASSTYPE_MTABLE_ENTRY (tem[len*2]); - - prev_type_stack = type_stack; - prev_type_memoized = type_stack->type; - } - - if (flag_memoize_lookups) - { - len = type_stack->len; - while (len--) - CLASSTYPE_MTABLE_ENTRY (tem[len*2]) - = (char *)MEMOIZED_CHAIN (CLASSTYPE_MTABLE_ENTRY (tem[len*2])); - } - if (! use_old) - type_stack = pop_type_level (type_stack); - else - type_stack = (struct type_level *)type_stack->base.prev; -} - -/* This can go away when the new searching strategy as a little mileage on it. */ -#define NEW_SEARCH 1 -#if NEW_SEARCH -/* This is the newer recursive depth first one, the old one follows. */ -static tree -get_binfo_recursive (binfo, is_private, parent, rval, rval_private_ptr, xtype, - friends, protect) - tree binfo, parent, rval, xtype, friends; - int *rval_private_ptr, protect, is_private; -{ - tree binfos; - int i, n_baselinks; - - if (BINFO_TYPE (binfo) == parent) - { - if (rval == NULL_TREE) - { - rval = binfo; - *rval_private_ptr = is_private; - } - else - { - /* I believe it is the case that this error is only an error - when used by someone that wants error messages printed. - Routines that call this one, that don't set protect want - the first one found, even if there are more. */ - if (protect) - { - /* Found two or more possible return values. */ - error_with_aggr_type (parent, "type `%s' is ambiguous base class for type `%s'", - TYPE_NAME_STRING (xtype)); - rval = error_mark_node; - } - } - return rval; - } - - binfos = BINFO_BASETYPES (binfo); - n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - /* Process base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - - if (BINFO_MARKED (base_binfo) == 0) - { - int via_private = is_private || !TREE_VIA_PUBLIC (base_binfo); - - SET_BINFO_MARKED (base_binfo); - - if (via_private == 0) - ; - else if (protect == 0) - via_private = 0; - else if (protect == 1 && BINFO_TYPE (binfo) == current_class_type) - /* The immediate base class of the class we are in - does let its public members through. */ - via_private = 0; -#ifndef NOJJG - else if (protect - && friends != NULL_TREE - && BINFO_TYPE (binfo) == xtype - && value_member (current_class_type, friends)) - /* Friend types of the most derived type have access - to its baseclass pointers. */ - via_private = 0; -#endif - - rval = get_binfo_recursive (base_binfo, via_private, parent, rval, - rval_private_ptr, xtype, friends, - protect); - if (rval == error_mark_node) - return rval; - } - } - - return rval; -} - -/* Check whether the type given in BINFO is derived from PARENT. If - it isn't, return 0. If it is, but the derivation is MI-ambiguous - AND protect != 0, emit an error message and return error_mark_node. - - Otherwise, if TYPE is derived from PARENT, return the actual base - information, unless a one of the protection violations below - occurs, in which case emit an error message and return error_mark_node. - - The below should be worded better. It may not be exactly what the code - does, but there should be a lose correlation. If you understand the code - well, please try and make the comments below more readable. - - If PROTECT is 1, then check if access to a public field of PARENT - would be private. - - If PROTECT is 2, then check if the given type is derived from - PARENT via private visibility rules. - - If PROTECT is 3, then immediately private baseclass is ok, - but deeper than that, check if private. */ -tree -get_binfo (parent, binfo, protect) - register tree parent, binfo; - int protect; -{ - tree xtype, type; - tree otype; - int head = 0, tail = 0; - int is_private = 0; - tree rval = NULL_TREE; - int rval_private = 0; - tree friends; - -#ifdef GATHER_STATISTICS - n_calls_get_base_type++; -#endif - - if (TREE_CODE (parent) == TREE_VEC) - parent = BINFO_TYPE (parent); - /* unions cannot participate in inheritance relationships */ - else if (TREE_CODE (parent) == UNION_TYPE) - return NULL_TREE; - else if (TREE_CODE (parent) != RECORD_TYPE) - my_friendly_abort (89); - - parent = TYPE_MAIN_VARIANT (parent); - - if (TREE_CODE (binfo) == TREE_VEC) - type = BINFO_TYPE (binfo); - else if (TREE_CODE (binfo) == RECORD_TYPE) - { - type = binfo; - binfo = TYPE_BINFO (type); - } - else my_friendly_abort (90); - xtype = type; - friends = current_class_type ? CLASSTYPE_FRIEND_CLASSES (type) : NULL_TREE; - - rval = get_binfo_recursive (binfo, is_private, parent, rval, &rval_private, - xtype, friends, protect); - - dfs_walk (binfo, dfs_unmark, markedp); - - if (rval && protect && rval_private) - { - if (protect == 3) - { - tree binfos = BINFO_BASETYPES (TYPE_BINFO (xtype)); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - if (parent == BINFO_TYPE (base_binfo)) - /* It's ok, since it's immediate. */ - return rval; - } - } - error_with_aggr_type (xtype, "type `%s' is derived from private `%s'", - TYPE_NAME_STRING (parent)); - return error_mark_node; - } - - return rval; -} -#else -/* Check whether the type given in BINFO is derived from PARENT. If - it isn't, return 0. If it is, but the derivation is MI-ambiguous - AND protect != 0, emit an error message and return error_mark_node. - - Otherwise, if TYPE is derived from PARENT, return the actual base - information, unless a one of the protection violations below - occurs, in which case emit an error message and return error_mark_node. - - The below should be worded better. It may not be exactly what the code - does, but there should be a lose correlation. If you understand the code - well, please try and make the comments below more readable. - - If PROTECT is 1, then check if access to a public field of PARENT - would be private. - - If PROTECT is 2, then check if the given type is derived from - PARENT via private visibility rules. - - If PROTECT is 3, then immediately private baseclass is ok, - but deeper than that, check if private. */ -tree -get_binfo (parent, binfo, protect) - register tree parent, binfo; - int protect; -{ - tree xtype, type; - tree otype; - int head = 0, tail = 0; - int is_private = 0; - tree rval = NULL_TREE; - int rval_private = 0; - tree friends; - -#ifdef GATHER_STATISTICS - n_calls_get_base_type++; -#endif - - if (TREE_CODE (parent) == TREE_VEC) - parent = BINFO_TYPE (parent); - /* unions cannot participate in inheritance relationships */ - else if (TREE_CODE (parent) == UNION_TYPE) - return NULL_TREE; - else if (TREE_CODE (parent) != RECORD_TYPE) - my_friendly_abort (89); - - parent = TYPE_MAIN_VARIANT (parent); - search_stack = push_search_level (search_stack, &search_obstack); - - if (TREE_CODE (binfo) == TREE_VEC) - type = BINFO_TYPE (binfo); - else if (TREE_CODE (binfo) == RECORD_TYPE) - { - type = binfo; - binfo = TYPE_BINFO (type); - } - else my_friendly_abort (90); - xtype = type; - friends = current_class_type ? CLASSTYPE_FRIEND_CLASSES (type) : NULL_TREE; - - while (1) - { - tree binfos = BINFO_BASETYPES (binfo); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - /* Process and/or queue base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - - if (BINFO_MARKED (base_binfo) == 0) - { - int via_private = is_private || !TREE_VIA_PUBLIC (base_binfo); - - SET_BINFO_MARKED (base_binfo); - - if (via_private == 0) - ; - else if (protect == 0) - via_private = 0; - else if (protect == 1 && BINFO_TYPE (binfo) == current_class_type) - /* The immediate base class of the class we are in - does let its public members through. */ - via_private = 0; -#ifndef NOJJG - else if (protect - && friends != NULL_TREE - && BINFO_TYPE (binfo) == xtype - && value_member (current_class_type, friends)) - /* Friend types of the most derived type have access - to its baseclass pointers. */ - via_private = 0; -#endif - - otype = type; - obstack_ptr_grow (&search_obstack, base_binfo); - obstack_ptr_grow (&search_obstack, (void *) via_private); - tail += 2; - if (tail >= search_stack->limit) - my_friendly_abort (91); - } -#if 0 - /* This code cannot possibly be right. Ambiguities can only be - checked by traversing the whole tree, and seeing if it pops - up twice. */ - else if (protect && ! TREE_VIA_VIRTUAL (base_binfo)) - { - error_with_aggr_type (parent, "type `%s' is ambiguous base class for type `%s'", - TYPE_NAME_STRING (xtype)); - error ("(base class for types `%s' and `%s')", - TYPE_NAME_STRING (BINFO_TYPE (binfo)), - TYPE_NAME_STRING (otype)); - rval = error_mark_node; - goto cleanup; - } -#endif - } - - dont_queue: - /* Process head of queue, if one exists. */ - if (head >= tail) - break; - - binfo = search_stack->first[head++]; - is_private = (int) search_stack->first[head++]; - if (BINFO_TYPE (binfo) == parent) - { - if (rval == 0) - { - rval = binfo; - rval_private = is_private; - } - else - /* I believe it is the case that this error is only an error when - used by someone that wants error messages printed. Routines that - call this one, that don't set protect want the first one found, - even if there are more. */ - if (protect) - { - /* Found two or more possible return values. */ - error_with_aggr_type (parent, "type `%s' is ambiguous base class for type `%s'", - TYPE_NAME_STRING (xtype)); - rval = error_mark_node; - goto cleanup; - } - goto dont_queue; - } - } - - cleanup: - { - tree *tp = search_stack->first; - tree *search_tail = tp + tail; - - while (tp < search_tail) - { - CLEAR_BINFO_MARKED (*tp); - tp += 2; - } - } - search_stack = pop_search_level (search_stack); - - if (rval == error_mark_node) - return error_mark_node; - - if (rval && protect && rval_private) - { - if (protect == 3) - { - tree binfos = BINFO_BASETYPES (TYPE_BINFO (xtype)); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - if (parent == BINFO_TYPE (base_binfo)) - /* It's ok, since it's immediate. */ - return rval; - } - } - error_with_aggr_type (xtype, "type `%s' is derived from private `%s'", - TYPE_NAME_STRING (parent)); - return error_mark_node; - } - - return rval; -} -#endif - -#if NEW_SEARCH -/* This is the newer depth first get_base_distance, the older one follows. */ -static -get_base_distance_recursive (binfo, depth, is_private, basetype_path, rval, - rval_private_ptr, new_binfo_ptr, parent, path_ptr, - protect, via_virtual_ptr, via_virtual) - tree binfo, basetype_path, *new_binfo_ptr, parent, *path_ptr; - int *rval_private_ptr, depth, is_private, rval, protect, *via_virtual_ptr, - via_virtual; -{ - tree binfos; - int i, n_baselinks; - - if (BINFO_TYPE (binfo) == parent) - { - if (rval == -1) - { - rval = depth; - *rval_private_ptr = is_private; - *new_binfo_ptr = binfo; - *via_virtual_ptr = via_virtual; - } - else - { - int same_object = tree_int_cst_equal (BINFO_OFFSET (*new_binfo_ptr), - BINFO_OFFSET (binfo)); - - if (*via_virtual_ptr && via_virtual==0) - { - *rval_private_ptr = is_private; - *new_binfo_ptr = binfo; - *via_virtual_ptr = via_virtual; - } - else if (same_object) - { - /* Note, this should probably succeed to find, and - override the old one if the old one was private and - this one isn't. */ - return rval; - } - - rval = -2; - } - return rval; - } - - binfos = BINFO_BASETYPES (binfo); - n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - depth += 1; - - /* Process base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - - if (BINFO_MARKED (base_binfo) == 0) - { - int via_private = is_private || !TREE_VIA_PUBLIC (base_binfo); - int was; - - /* When searching for a non-virtual, we cannot mark - virtually found binfos. */ - if (!via_virtual) - SET_BINFO_MARKED (base_binfo); - - if (via_private == 0) - ; - else if (protect == 0) - via_private = 0; - -#define WATCH_VALUES(rval, via_private) (rval == -1 ? 3 : via_private) - - was = WATCH_VALUES (rval, *via_virtual_ptr); - rval = get_base_distance_recursive (base_binfo, depth, via_private, - binfo, rval, rval_private_ptr, - new_binfo_ptr, parent, path_ptr, - protect, via_virtual_ptr, - TREE_VIA_VIRTUAL (base_binfo)|via_virtual); - /* watch for updates, only update, if path is good. */ - if (path_ptr && WATCH_VALUES (rval, *via_virtual_ptr) != was) - BINFO_INHERITANCE_CHAIN (base_binfo) = binfo; - if (rval == -2 && *via_virtual_ptr == 0) - return rval; - -#undef WATCH_VALUES - - } - } - - return rval; -} - -/* Return the number of levels between type PARENT and the type given - in BINFO, following the leftmost path to PARENT not found along a - virtual path, if there are no real PARENTs (all come from virtual - base classes), then follow the leftmost path to PARENT. - - Return -1 if TYPE is not derived from PARENT. - Return -2 if PARENT is an ambiguous base class of TYPE. - Return -3 if PARENT is private to TYPE, and protect is non-zero. - - If PATH_PTR is non-NULL, then also build the list of types - from PARENT to TYPE, with TREE_VIA_VIRUAL and TREE_VIA_PUBLIC - set. - - It is unclear whether or not the path should be built if -2 and/or - -3 is returned. Maybe, maybe not. I suspect that there is code - that relies upon it being built, such as prepare_fresh_vtable. - (mrs) - - Also, it would appear that we only sometimes want -2. The question is - under what exact conditions do we want to see -2, and when do we not - want to see -2. (mrs) - - It is also unlikely that this thing finds all ambiguties, as I - don't trust any deviation from the method used in get_binfo. It - would be nice to use that method here, as it is simple and straight - forward. The code here and in recursive_bounded_basetype_p is not. - For now, I shall include an extra call to find ambiguities. (mrs) - */ - -int -get_base_distance (parent, binfo, protect, path_ptr) - register tree parent, binfo; - int protect; - tree *path_ptr; -{ - int head, tail; - int is_private = 0; - int rval = -1; - int depth = 0; - int rval_private = 0; - tree type, basetype_path; - tree friends; - int use_leftmost; - tree new_binfo; - int via_virtual; - - if (TYPE_READONLY (parent) || TYPE_VOLATILE (parent)) - parent = TYPE_MAIN_VARIANT (parent); - use_leftmost = (parent == TYPE_MAIN_VARIANT (parent)); - - if (TREE_CODE (binfo) == TREE_VEC) - type = BINFO_TYPE (binfo); - else if (TREE_CODE (binfo) == RECORD_TYPE) - { - type = binfo; - binfo = TYPE_BINFO (type); - } - else my_friendly_abort (92); - - friends = current_class_type ? CLASSTYPE_FRIEND_CLASSES (type) : NULL_TREE; - - if (path_ptr) - { - basetype_path = TYPE_BINFO (type); - BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE; - } - - if (TYPE_MAIN_VARIANT (parent) == type) - { - /* If the distance is 0, then we don't really need - a path pointer, but we shouldn't let garbage go back. */ - if (path_ptr) - *path_ptr = basetype_path; - return 0; - } - - rval = get_base_distance_recursive (binfo, 0, 0, NULL_TREE, rval, - &rval_private, &new_binfo, parent, - path_ptr, protect, &via_virtual, 0); - - if (path_ptr) - BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE; - - basetype_path = binfo; - - dfs_walk (binfo, dfs_unmark, markedp); - - binfo = new_binfo; - - /* Visibilities don't count if we found an ambiguous basetype. */ - if (rval == -2) - rval_private = 0; - - if (rval && protect && rval_private) - return -3; - - if (path_ptr) - *path_ptr = binfo; - return rval; -} -#else -/* Recursively search for a path from PARENT to BINFO. - If RVAL is > 0 and we succeed, update the BINFO_INHERITANCE_CHAIN - pointers. - If we find a distinct basetype that's not the one from BINFO, - return -2; - If we don't find any path, return 0. - - If we encounter a virtual basetype on the path, return RVAL - and don't change any pointers after that point. */ -static int -recursive_bounded_basetype_p (parent, binfo, rval, update_chain) - tree parent, binfo; - int rval; - int update_chain; -{ - tree binfos; - - if (BINFO_TYPE (parent) == BINFO_TYPE (binfo)) - { - if (tree_int_cst_equal (BINFO_OFFSET (parent), BINFO_OFFSET (binfo))) - return rval; - return -2; - } - - if (TREE_VIA_VIRTUAL (binfo)) - update_chain = 0; - - if (binfos = BINFO_BASETYPES (binfo)) - { - int i, nval; - for (i = 0; i < TREE_VEC_LENGTH (binfos); i++) - { - nval = recursive_bounded_basetype_p (parent, TREE_VEC_ELT (binfos, i), - rval, update_chain); - if (nval < 0) - return nval; - if (nval > 0 && update_chain) - BINFO_INHERITANCE_CHAIN (TREE_VEC_ELT (binfos, i)) = binfo; - } - return rval; - } - return 0; -} - -/* -------------------------------------------------- */ -/* These two routines are ONLY here to check for ambiguities for - get_base_distance, as it probably cannot check by itself for - all ambiguities. When get_base_distance is sure to check for all, - these routines can go. (mrs) */ - -static tree -get_binfo2_recursive (binfo, parent, type) - register tree binfo, parent; - tree type; -{ - tree rval = NULL_TREE; - tree nrval; - tree binfos = BINFO_BASETYPES (binfo); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - if (BINFO_TYPE (binfo) == parent) - { - return binfo; - } - - /* Process base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - - if (BINFO_MARKED (base_binfo) == 0) - { - SET_BINFO_MARKED (base_binfo); - - nrval = get_binfo2_recursive (base_binfo, parent, type); - - if (nrval == error_mark_node) - return nrval; - if (nrval) - if (rval == 0) - { - rval = nrval; - } - else - return error_mark_node; - } - } - return rval; -} - -static tree -get_binfo2 (parent, binfo) - register tree parent, binfo; -{ - tree type; - tree rval = NULL_TREE; - - if (TREE_CODE (parent) == TREE_VEC) - parent = BINFO_TYPE (parent); - /* unions cannot participate in inheritance relationships */ - else if (TREE_CODE (parent) == UNION_TYPE) - return 0; - else if (TREE_CODE (parent) != RECORD_TYPE) - my_friendly_abort (89); - - parent = TYPE_MAIN_VARIANT (parent); - - if (TREE_CODE (binfo) == TREE_VEC) - type = BINFO_TYPE (binfo); - else if (TREE_CODE (binfo) == RECORD_TYPE) - { - type = binfo; - binfo = TYPE_BINFO (type); - } - else my_friendly_abort (90); - - rval = get_binfo2_recursive (binfo, parent, type); - - dfs_walk (binfo, dfs_unmark, markedp); - - return rval; -} - -/* -------------------------------------------------- */ - -/* Return the number of levels between type PARENT and the type given - in BINFO, following the leftmost path to PARENT. If PARENT is its - own main type variant, then if PARENT appears in different places - from TYPE's point of view, the leftmost PARENT will be the one - chosen. - - Return -1 if TYPE is not derived from PARENT. - Return -2 if PARENT is an ambiguous base class of TYPE. - Return -3 if PARENT is private to TYPE, and protect is non-zero. - - If PATH_PTR is non-NULL, then also build the list of types - from PARENT to TYPE, with TREE_VIA_VIRUAL and TREE_VIA_PUBLIC - set. - - It is unclear whether or not the path should be built if -2 and/or - -3 is returned. Maybe, maybe not. I suspect that there is code - that relies upon it being built, such as prepare_fresh_vtable. - (mrs) - - Also, it would appear that we only sometimes want -2. The question is - under what exact conditions do we want to see -2, and when do we not - want to see -2. (mrs) - - It is also unlikely that this thing finds all ambiguties, as I - don't trust any deviation from the method used in get_binfo. It - would be nice to use that method here, as it is simple and straight - forward. The code here and in recursive_bounded_basetype_p is not. - For now, I shall include an extra call to find ambiguities. (mrs) - */ - -int -get_base_distance (parent, binfo, protect, path_ptr) - register tree parent, binfo; - int protect; - tree *path_ptr; -{ - int head, tail; - int is_private = 0; - int rval = -1; - int depth = 0; - int rval_private = 0; - tree type, basetype_path; - tree friends; - int use_leftmost; - - if (TYPE_READONLY (parent) || TYPE_VOLATILE (parent)) - parent = TYPE_MAIN_VARIANT (parent); - use_leftmost = (parent == TYPE_MAIN_VARIANT (parent)); - - if (TREE_CODE (binfo) == TREE_VEC) - type = BINFO_TYPE (binfo); - else if (TREE_CODE (binfo) == RECORD_TYPE) - { - type = binfo; - binfo = TYPE_BINFO (type); - } - else if (TREE_CODE (binfo) == UNION_TYPE) - { - /* UNION_TYPEs do not participate in inheritance relationships. */ - return -1; - } - else my_friendly_abort (92); - - friends = current_class_type ? CLASSTYPE_FRIEND_CLASSES (type) : NULL_TREE; - - if (path_ptr) - { - basetype_path = TYPE_BINFO (type); - BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE; - } - - if (TYPE_MAIN_VARIANT (parent) == type) - { - /* If the distance is 0, then we don't really need - a path pointer, but we shouldn't let garbage go back. */ - if (path_ptr) - *path_ptr = basetype_path; - return 0; - } - - search_stack = push_search_level (search_stack, &search_obstack); - - /* Keep space for TYPE. */ - obstack_ptr_grow (&search_obstack, binfo); - obstack_ptr_grow (&search_obstack, NULL_PTR); - obstack_ptr_grow (&search_obstack, NULL_PTR); - if (path_ptr) - { - obstack_ptr_grow (&search_obstack, NULL_PTR); - head = 4; - } - else head = 3; - tail = head; - - while (1) - { - tree binfos = BINFO_BASETYPES (binfo); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - /* Process and/or queue base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - - if (BINFO_MARKED (base_binfo) == 0) - { - int via_private = is_private || !TREE_VIA_PUBLIC (base_binfo); - - SET_BINFO_MARKED (base_binfo); - - if (via_private == 0) - ; - else if (protect == 0) - via_private = 0; - - obstack_ptr_grow (&search_obstack, base_binfo); - obstack_ptr_grow (&search_obstack, (HOST_WIDE_INT) depth); - obstack_ptr_grow (&search_obstack, (HOST_WIDE_INT) via_private); - tail += 3; - if (path_ptr) - { - obstack_ptr_grow (&search_obstack, basetype_path); - tail += 1; - } - if (tail >= search_stack->limit) - my_friendly_abort (93); - } -#if 0 - /* This code cannot possibly be right. Ambiguities can only be - checked by traversing the whole tree, and seeing if it pops - up twice. */ - else if (! TREE_VIA_VIRTUAL (base_binfo)) - { - rval = -2; - goto done; - } -#endif - } - - /* Process head of queue, if one exists. */ - if (head >= tail) - break; - - binfo = search_stack->first[head++]; - depth = (int) search_stack->first[head++] + 1; - is_private = (int) search_stack->first[head++]; - if (path_ptr) - { - basetype_path = search_stack->first[head++]; - BINFO_INHERITANCE_CHAIN (binfo) = basetype_path; - basetype_path = binfo; - } - if (BINFO_TYPE (binfo) == parent) - { - /* It is wrong to set this and break, the proper thing to do - would be to set it only if it has not been set before, - and if is has been set, an ambiguity exists, and just - continue searching the tree for more of them as is done - in get_binfo. But until the code below can cope, this - can't be done. Also, it is not clear what should happen if - use_leftmost is set. */ - rval = depth; - rval_private = is_private; - break; - } - } -#if 0 - /* Unneeded now, as we know the above code in the #if 0 is wrong. */ - done: -#endif - { - int increment = path_ptr ? 4 : 3; - tree *tp = search_stack->first; - tree *search_tail = tp + tail; - - /* We can skip the first entry, since it wasn't marked. */ - tp += increment; - - basetype_path = binfo; - while (tp < search_tail) - { - CLEAR_BINFO_MARKED (*tp); - tp += increment; - } - - /* Now, guarantee that we are following the leftmost path in the - chain. Algorithm: the search stack holds tuples in BFS order. - The last tuple on the search stack contains the tentative binfo - for the basetype we are looking for. We know that starting - with FIRST, each tuple with only a single basetype must be on - the leftmost path. Each time we come to a split, we select - the tuple for the leftmost basetype that can reach the ultimate - basetype. */ - - if (use_leftmost - && rval > 0 - && (! BINFO_OFFSET_ZEROP (binfo) || TREE_VIA_VIRTUAL (binfo))) - { - tree tp_binfos; - - /* Farm out the tuples with a single basetype. */ - for (tp = search_stack->first; tp < search_tail; tp += increment) - { - tp_binfos = BINFO_BASETYPES (*tp); - if (tp_binfos && TREE_VEC_LENGTH (tp_binfos) > 1) - break; - } - - if (tp < search_tail) - { - /* Pick the best path. */ - tree base_binfo; - int i; - int nrval = rval; - for (i = 0; i < TREE_VEC_LENGTH (tp_binfos); i++) - { - base_binfo = TREE_VEC_ELT (tp_binfos, i); - if (tp+((i+1)*increment) < search_tail) - my_friendly_assert (base_binfo == tp[(i+1)*increment], 295); - if (nrval = recursive_bounded_basetype_p (binfo, base_binfo, rval, 1)) - break; - } - rval = nrval; - if (rval > 0) - BINFO_INHERITANCE_CHAIN (base_binfo) = *tp; - } - - /* Because I don't trust recursive_bounded_basetype_p to find - all ambiguities, I will just make sure here. When it is - sure that all ambiguities are found, the two routines and - this call can be removed. Not toally sure this should be - here, but I think it should. (mrs) */ - - if (get_binfo2 (parent, type) == error_mark_node && rval != -2) - { -#if 1 - /* This warning is here because the code over in - prepare_fresh_vtable relies on partial completion - offered by recursive_bounded_basetype_p I think, but - that behavior is not documented. It needs to be. I - don't think prepare_fresh_vtable is the only routine - that relies upon path_ptr being set to something in a - particular way when this routine returns -2. (mrs) */ - /* See PR 428 for a test case that can tickle this. */ - warning ("internal consistency check failed, please report, recovering."); - rval = -2; -#endif - } - - /* Visibilities don't count if we found an ambiguous basetype. */ - if (rval == -2) - rval_private = 0; - } - } - search_stack = pop_search_level (search_stack); - - if (rval && protect && rval_private) - return -3; - - if (path_ptr) - *path_ptr = binfo; - return rval; -} -#endif - -/* Search for a member with name NAME in a multiple inheritance lattice - specified by TYPE. If it does not exist, return NULL_TREE. - If the member is ambiguously referenced, return `error_mark_node'. - Otherwise, return the FIELD_DECL. */ - -/* Do a 1-level search for NAME as a member of TYPE. The caller - must figure out whether it has a visible path to this field. - (Since it is only one level, this is reasonable.) */ -static tree -lookup_field_1 (type, name) - tree type, name; -{ - register tree field = TYPE_FIELDS (type); - -#ifdef GATHER_STATISTICS - n_calls_lookup_field_1++; -#endif - while (field) - { -#ifdef GATHER_STATISTICS - n_fields_searched++; -#endif - if (DECL_NAME (field) == NULL_TREE - && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE) - { - tree temp = lookup_field_1 (TREE_TYPE (field), name); - if (temp) - return temp; - } - if (DECL_NAME (field) == name) - { - if ((TREE_CODE(field) == VAR_DECL || TREE_CODE(field) == CONST_DECL) - && DECL_ASSEMBLER_NAME (field) != NULL) - GNU_xref_ref(current_function_decl, - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (field))); - return field; - } - field = TREE_CHAIN (field); - } - /* Not found. */ - if (name == _vptr_name) - { - /* Give the user what s/he thinks s/he wants. */ - if (TYPE_VIRTUAL_P (type)) - return CLASSTYPE_VFIELD (type); - } - return NULL_TREE; -} - -/* Compute the visibility of FIELD. This is done by computing - the visibility available to each type in BASETYPES (which comes - as a list of [via_public/basetype] in reverse order, namely base - class before derived class). The first one which defines a - visibility defines the visibility for the field. Otherwise, the - visibility of the field is that which occurs normally. - - Uses global variables CURRENT_CLASS_TYPE and - CURRENT_FUNCTION_DECL to use friend relationships - if necessary. - - This will be static when lookup_fnfield comes into this file. */ - -#define PUBLIC_RETURN return (DECL_PUBLIC (field) = 1), visibility_public -#define PROTECTED_RETURN return (DECL_PROTECTED (field) = 1), visibility_protected -#define PRIVATE_RETURN return (DECL_PRIVATE (field) = 1), visibility_private - -enum visibility_type -compute_visibility (basetype_path, field) - tree basetype_path, field; -{ - enum visibility_type visibility = visibility_public; - tree types; - tree context = DECL_CLASS_CONTEXT (field); - - /* Fields coming from nested anonymous unions have their DECL_CLASS_CONTEXT - slot set to the union type rather than the record type containing - the anonymous union. In this case, DECL_FIELD_CONTEXT is correct. */ - if (context && TREE_CODE (context) == UNION_TYPE - && ANON_AGGRNAME_P (TYPE_IDENTIFIER (context))) - context = DECL_FIELD_CONTEXT (field); - - /* Virtual function tables are never private. - But we should know that we are looking for this, - and not even try to hide it. */ - if (DECL_NAME (field) && VFIELD_NAME_P (DECL_NAME (field)) == 1) - return visibility_public; - - /* Member function manipulating its own members. */ - if (current_class_type == context - || (context && current_class_type == TYPE_MAIN_VARIANT (context))) - PUBLIC_RETURN; - - /* Make these special cases fast. */ - if (BINFO_TYPE (basetype_path) == current_class_type) - { - if (DECL_PUBLIC (field)) - return visibility_public; - if (DECL_PROTECTED (field)) - return visibility_protected; - if (DECL_PRIVATE (field)) - return visibility_private; - } - - /* Member found immediately within object. */ - if (BINFO_INHERITANCE_CHAIN (basetype_path) == NULL_TREE) - { - /* At object's top level, public members are public. */ - if (TREE_PROTECTED (field) == 0 && TREE_PRIVATE (field) == 0) - PUBLIC_RETURN; - - /* Friend function manipulating members it gets (for being a friend). */ - if (is_friend (context, current_function_decl)) - PUBLIC_RETURN; - - /* Inner than that, without special visibility, - - protected members are ok if type of object is current_class_type - is derived therefrom. This means that if the type of the object - is a base type for our current class type, we cannot access - protected members. - - private members are not ok. */ - if (current_class_type && DECL_VISIBILITY (field) == NULL_TREE) - { - if (TREE_PRIVATE (field)) - PRIVATE_RETURN; - - if (TREE_PROTECTED (field)) - { - if (context == current_class_type - || UNIQUELY_DERIVED_FROM_P (context, current_class_type)) - PUBLIC_RETURN; - else - PROTECTED_RETURN; - } - else my_friendly_abort (94); - } - } - /* Friend function manipulating members it gets (for being a friend). */ - if (is_friend (context, current_function_decl)) - PUBLIC_RETURN; - - /* must reverse more than one element */ - basetype_path = reverse_path (basetype_path); - types = basetype_path; - - while (types) - { - tree member; - tree binfo = types; - tree type = BINFO_TYPE (binfo); - - member = purpose_member (type, DECL_VISIBILITY (field)); - if (member) - { - visibility = (enum visibility_type)TREE_VALUE (member); - if (visibility == visibility_public - || is_friend (type, current_function_decl) - || (visibility == visibility_protected - && current_class_type - && UNIQUELY_DERIVED_FROM_P (context, current_class_type))) - visibility = visibility_public; - goto ret; - } - - /* Friends inherit the visibility of the class they inherit from. */ - if (is_friend (type, current_function_decl)) - { - if (type == context) - { - visibility = visibility_public; - goto ret; - } - if (TREE_PROTECTED (field)) - { - visibility = visibility_public; - goto ret; - } -#if 0 - /* This short-cut is too short. */ - if (visibility == visibility_public) - goto ret; -#endif - /* else, may be a friend of a deeper base class */ - } - - if (type == context) - break; - - types = BINFO_INHERITANCE_CHAIN (types); - /* If the next type was not VIA_PUBLIC, then fields of all - remaining class past that one are private. */ - if (types) - { - if (TREE_VIA_PROTECTED (types)) - visibility = visibility_protected; - else if (! TREE_VIA_PUBLIC (types)) - visibility = visibility_private; - } - } - - /* No special visibilities apply. Use normal rules. - No assignment needed for BASETYPEs here from the nreverse. - This is because we use it only for information about the - path to the base. The code earlier dealt with what - happens when we are at the base level. */ - - if (visibility == visibility_public) - { - basetype_path = reverse_path (basetype_path); - if (TREE_PRIVATE (field)) - PRIVATE_RETURN; - if (TREE_PROTECTED (field)) - { - /* Used to check if the current class type was derived from - the type that contains the field. This is wrong for - multiple inheritance because is gives one class reference - to protected members via another classes protected path. - I.e., if A; B1 : A; B2 : A; Then B1 and B2 can access - their own members which are protected in A, but not - those same members in one another. */ - if (current_class_type - && UNIQUELY_DERIVED_FROM_P (context, current_class_type)) - PUBLIC_RETURN; - PROTECTED_RETURN; - } - PUBLIC_RETURN; - } - - if (visibility == visibility_protected) - { - /* reverse_path? */ - if (TREE_PRIVATE (field)) - PRIVATE_RETURN; - /* We want to make sure that all non-private members in - the current class (as derived) are accessible. */ - if (current_class_type - && UNIQUELY_DERIVED_FROM_P (context, current_class_type)) - PUBLIC_RETURN; - PROTECTED_RETURN; - } - - if (visibility == visibility_private - && current_class_type != NULL_TREE) - { - if (TREE_PRIVATE (field)) - { - reverse_path (basetype_path); - PRIVATE_RETURN; - } - - /* See if the field isn't protected. */ - if (TREE_PROTECTED (field)) - { - tree test = basetype_path; - while (test) - { - if (BINFO_TYPE (test) == current_class_type) - break; - test = BINFO_INHERITANCE_CHAIN (test); - } - reverse_path (basetype_path); - if (test) - PUBLIC_RETURN; - PROTECTED_RETURN; - } - - /* See if the field isn't a public member of - a private base class. */ - - visibility = visibility_public; - types = BINFO_INHERITANCE_CHAIN (basetype_path); - while (types) - { - if (! TREE_VIA_PUBLIC (types)) - { - if (visibility == visibility_private) - { - visibility = visibility_private; - goto ret; - } - visibility = visibility_private; - } - if (BINFO_TYPE (types) == context) - { - visibility = visibility_public; - goto ret; - } - types = BINFO_INHERITANCE_CHAIN (types); - } - my_friendly_abort (95); - } - - ret: - reverse_path (basetype_path); - - if (visibility == visibility_public) - DECL_PUBLIC (field) = 1; - else if (visibility == visibility_protected) - DECL_PROTECTED (field) = 1; - else if (visibility == visibility_private) - DECL_PRIVATE (field) = 1; - else my_friendly_abort (96); - return visibility; -} - -/* Routine to see if the sub-object denoted by the binfo PARENT can be - found as a base class and sub-object of the object denoted by - BINFO. This routine relies upon binfos not being shared, except - for binfos for virtual bases. */ -static int -is_subobject_of_p (parent, binfo) - tree parent, binfo; -{ - tree binfos = BINFO_BASETYPES (binfo); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - if (parent == binfo) - return 1; - - /* Process and/or queue base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - if (TREE_VIA_VIRTUAL (base_binfo)) - base_binfo = TYPE_BINFO (BINFO_TYPE (base_binfo)); - if (is_subobject_of_p (parent, base_binfo)) - return 1; - } - return 0; -} - -/* See if a one FIELD_DECL hides another. This routine is meant to - correspond to ANSI working paper Sept 17, 1992 10p4. The two - binfos given are the binfos corresponding to the particular places - the FIELD_DECLs are found. This routine relies upon binfos not - being shared, except for virtual bases. */ -static int -hides (hider_binfo, hidee_binfo) - tree hider_binfo, hidee_binfo; -{ - /* hider hides hidee, if hider has hidee as a base class and - the instance of hidee is a sub-object of hider. The first - part is always true is the second part is true. - - When hider and hidee are the same (two ways to get to the exact - same member) we consider either one as hiding the other. */ - return is_subobject_of_p (hidee_binfo, hider_binfo); -} - -/* Very similar to lookup_fnfields_1 but it ensures that at least one - function was declared inside the class given by TYPE. It really should - only return functions that match the given TYPE. */ -static int -lookup_fnfields_here (type, name) - tree type, name; -{ - int index = lookup_fnfields_1 (type, name); - tree fndecls; - - if (index <= 0) - return index; - fndecls = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index); - while (fndecls) - { - if (TYPE_MAIN_VARIANT (DECL_CLASS_CONTEXT (fndecls)) - == TYPE_MAIN_VARIANT (type)) - return index; - fndecls = TREE_CHAIN (fndecls); - } - return -1; -} - -/* Look for a field named NAME in an inheritance lattice dominated by - XBASETYPE. PROTECT is zero if we can avoid computing visibility - information, otherwise it is 1. WANT_TYPE is 1 when we should only - return TYPE_DECLs, if no TYPE_DECL can be found return NULL_TREE. - - It was not clear what should happen if WANT_TYPE is set, and an - ambiguity is found. At least one use (lookup_name) to not see - the error. */ -tree -lookup_field (xbasetype, name, protect, want_type) - register tree xbasetype, name; - int protect, want_type; -{ - int head = 0, tail = 0; - tree rval, rval_binfo = NULL_TREE, rval_binfo_h; - tree type, basetype_chain, basetype_path; - enum visibility_type this_v = visibility_default; - tree entry, binfo, binfo_h; - enum visibility_type own_visibility = visibility_default; - int vbase_name_p = VBASE_NAME_P (name); - - /* rval_binfo is the binfo associated with the found member, note, - this can be set with useful information, even when rval is not - set, because it must deal with ALL members, not just non-function - members. It is used for ambiguity checking and the hidden - checks. Whereas rval is only set if a proper (not hidden) - non-function member is found. */ - - /* rval_binfo_h and binfo_h are binfo values used when we perform the - hiding checks, as virtual base classes may not be shared. The strategy - is we always go into the the binfo hierarchy owned by TYPE_BINFO of - virtual base classes, as we cross virtual base class lines. This way - we know that binfo of a virtual base class will always == itself when - found along any line. (mrs) */ - - /* Things for memoization. */ - char *errstr = 0; - - /* Set this to nonzero if we don't know how to compute - accurate error messages for visibility. */ - int index = MEMOIZED_HASH_FN (name); - - if (TREE_CODE (xbasetype) == TREE_VEC) - basetype_path = xbasetype, type = BINFO_TYPE (xbasetype); - else if (IS_AGGR_TYPE_CODE (TREE_CODE (xbasetype))) - basetype_path = TYPE_BINFO (xbasetype), type = xbasetype; - else my_friendly_abort (97); - - if (CLASSTYPE_MTABLE_ENTRY (type)) - { - tree tem = MEMOIZED_FIELDS (CLASSTYPE_MTABLE_ENTRY (type), index); - - while (tem && TREE_PURPOSE (tem) != name) - { - memoized_fields_searched[0]++; - tem = TREE_CHAIN (tem); - } - if (tem) - { - if (protect && TREE_TYPE (tem)) - { - error (TREE_STRING_POINTER (TREE_TYPE (tem)), - IDENTIFIER_POINTER (name), - TYPE_NAME_STRING (DECL_FIELD_CONTEXT (TREE_VALUE (tem)))); - return error_mark_node; - } - if (TREE_VALUE (tem) == NULL_TREE) - memoized_fast_rejects[0] += 1; - else - memoized_fast_finds[0] += 1; - return TREE_VALUE (tem); - } - } - -#ifdef GATHER_STATISTICS - n_calls_lookup_field++; -#endif - if (protect && flag_memoize_lookups && ! global_bindings_p ()) - entry = make_memoized_table_entry (type, name, 0); - else - entry = 0; - - rval = lookup_field_1 (type, name); - if (rval || lookup_fnfields_here (type, name)>=0) - { - rval_binfo = basetype_path; - rval_binfo_h = rval_binfo; - } - - if (rval && TREE_CODE (rval) != TYPE_DECL && want_type) - rval = NULL_TREE; - - if (rval) - { - if (protect) - { - if (TREE_PRIVATE (rval) | TREE_PROTECTED (rval)) - this_v = compute_visibility (basetype_path, rval); - if (TREE_CODE (rval) == CONST_DECL) - { - if (this_v == visibility_private) - errstr = "enum `%s' is a private value of class `%s'"; - else if (this_v == visibility_protected) - errstr = "enum `%s' is a protected value of class `%s'"; - } - else - { - if (this_v == visibility_private) - errstr = "member `%s' is a private member of class `%s'"; - else if (this_v == visibility_protected) - errstr = "member `%s' is a protected member of class `%s'"; - } - } - - if (entry) - { - if (errstr) - { - /* This depends on behavior of lookup_field_1! */ - tree error_string = my_build_string (errstr); - TREE_TYPE (entry) = error_string; - } - else - { - /* Let entry know there is no problem with this access. */ - TREE_TYPE (entry) = NULL_TREE; - } - TREE_VALUE (entry) = rval; - } - - if (errstr && protect) - { - error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type)); - return error_mark_node; - } - return rval; - } - - basetype_chain = CLASSTYPE_BINFO_AS_LIST (type); - TREE_VIA_PUBLIC (basetype_chain) = 1; - - /* The ambiguity check relies upon breadth first searching. */ - - search_stack = push_search_level (search_stack, &search_obstack); - BINFO_VIA_PUBLIC (basetype_path) = 1; - BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE; - binfo = basetype_path; - binfo_h = binfo; - - while (1) - { - tree binfos = BINFO_BASETYPES (binfo); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - tree nval; - - /* Process and/or queue base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - if (BINFO_FIELDS_MARKED (base_binfo) == 0) - { - tree btypes; - - SET_BINFO_FIELDS_MARKED (base_binfo); - btypes = my_tree_cons (NULL_TREE, base_binfo, basetype_chain); - TREE_VIA_PUBLIC (btypes) = TREE_VIA_PUBLIC (base_binfo); - TREE_VIA_PROTECTED (btypes) = TREE_VIA_PROTECTED (base_binfo); - TREE_VIA_VIRTUAL (btypes) = TREE_VIA_VIRTUAL (base_binfo); - if (TREE_VIA_VIRTUAL (base_binfo)) - btypes = tree_cons (NULL_TREE, - TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i))), - btypes); - else - btypes = tree_cons (NULL_TREE, - TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i), - btypes); - obstack_ptr_grow (&search_obstack, btypes); - tail += 1; - if (tail >= search_stack->limit) - my_friendly_abort (98); - } - } - - /* Process head of queue, if one exists. */ - if (head >= tail) - break; - - basetype_chain = search_stack->first[head++]; - binfo_h = TREE_VALUE (basetype_chain); - basetype_chain = TREE_CHAIN (basetype_chain); - basetype_path = TREE_VALUE (basetype_chain); - if (TREE_CHAIN (basetype_chain)) - BINFO_INHERITANCE_CHAIN (basetype_path) = TREE_VALUE (TREE_CHAIN (basetype_chain)); - else - BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE; - - binfo = basetype_path; - type = BINFO_TYPE (binfo); - - /* See if we can find NAME in TYPE. If RVAL is nonzero, - and we do find NAME in TYPE, verify that such a second - sighting is in fact legal. */ - - nval = lookup_field_1 (type, name); - - if (nval || lookup_fnfields_here (type, name)>=0) - { - if (rval_binfo && hides (rval_binfo_h, binfo_h)) - { - /* This is ok, the member found is in rval_binfo, not - here (binfo). */ - } - else if (rval_binfo==NULL_TREE || hides (binfo_h, rval_binfo_h)) - { - /* This is ok, the member found is here (binfo), not in - rval_binfo. */ - if (nval) - { - rval = nval; - if (entry || protect) - this_v = compute_visibility (basetype_path, rval); - /* These may look ambiguous, but they really are not. */ - if (vbase_name_p) - break; - } - else - { - /* Undo finding it before, as something else hides it. */ - rval = NULL_TREE; - } - rval_binfo = binfo; - rval_binfo_h = binfo_h; - } - else - { - /* This is ambiguous. */ - errstr = "request for member `%s' is ambiguous"; - protect = 2; - break; - } - } - } - { - tree *tp = search_stack->first; - tree *search_tail = tp + tail; - - if (entry) - TREE_VALUE (entry) = rval; - - if (want_type && (rval == NULL_TREE || TREE_CODE (rval) != TYPE_DECL)) - { - rval = NULL_TREE; - errstr = 0; - } - - /* If this FIELD_DECL defines its own visibility, deal with that. */ - if (rval && errstr == 0 - && ((protect&1) || entry) - && DECL_LANG_SPECIFIC (rval) - && DECL_VISIBILITY (rval)) - { - while (tp < search_tail) - { - /* If is possible for one of the derived types on the - path to have defined special visibility for this - field. Look for such declarations and report an - error if a conflict is found. */ - enum visibility_type new_v; - - if (this_v != visibility_default) - new_v = compute_visibility (TREE_VALUE (TREE_CHAIN (*tp)), rval); - if (this_v != visibility_default && new_v != this_v) - { - errstr = "conflicting visibilities to member `%s'"; - this_v = visibility_default; - } - own_visibility = new_v; - CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp))); - tp += 1; - } - } - else - { - while (tp < search_tail) - { - CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp))); - tp += 1; - } - } - } - search_stack = pop_search_level (search_stack); - - if (errstr == 0) - { - if (own_visibility == visibility_private) - errstr = "member `%s' declared private"; - else if (own_visibility == visibility_protected) - errstr = "member `%s' declared protected"; - else if (this_v == visibility_private) - errstr = TREE_PRIVATE (rval) - ? "member `%s' is private" - : "member `%s' is from private base class"; - else if (this_v == visibility_protected) - errstr = TREE_PROTECTED (rval) - ? "member `%s' is protected" - : "member `%s' is from protected base class"; - } - - if (entry) - { - if (errstr) - { - tree error_string = my_build_string (errstr); - /* Save error message with entry. */ - TREE_TYPE (entry) = error_string; - } - else - { - /* Mark entry as having no error string. */ - TREE_TYPE (entry) = NULL_TREE; - } - } - - if (errstr && protect) - { - error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type)); - rval = error_mark_node; - } - return rval; -} - -/* Try to find NAME inside a nested class. */ -tree -lookup_nested_field (name, complain) - tree name; - int complain; -{ - register tree t; - - tree id = NULL_TREE; - if (TREE_CHAIN (current_class_type)) - { - /* Climb our way up the nested ladder, seeing if we're trying to - modify a field in an enclosing class. If so, we should only - be able to modify if it's static. */ - for (t = TREE_CHAIN (current_class_type); - t && DECL_CONTEXT (t); - t = TREE_CHAIN (DECL_CONTEXT (t))) - { - if (TREE_CODE (DECL_CONTEXT (t)) != RECORD_TYPE) - break; - - /* N.B.: lookup_field will do the visibility checking for us */ - id = lookup_field (DECL_CONTEXT (t), name, complain, 0); - if (id == error_mark_node) - { - id = NULL_TREE; - continue; - } - - if (id != NULL_TREE) - { - if (TREE_CODE (id) == FIELD_DECL - && ! TREE_STATIC (id) - && TREE_TYPE (id) != error_mark_node) - { - if (complain) - { - /* At parse time, we don't want to give this error, since - we won't have enough state to make this kind of - decision properly. But there are times (e.g., with - enums in nested classes) when we do need to call - this fn at parse time. So, in those cases, we pass - complain as a 0 and just return a NULL_TREE. */ - error ("assignment to non-static member `%s' of enclosing class `%s'", - lang_printable_name (id), - IDENTIFIER_POINTER (TYPE_IDENTIFIER - (DECL_CONTEXT (t)))); - /* Mark this for do_identifier(). It would otherwise - claim that the variable was undeclared. */ - TREE_TYPE (id) = error_mark_node; - } - else - { - id = NULL_TREE; - continue; - } - } - break; - } - } - } - - return id; -} - -/* TYPE is a class type. Return the index of the fields within - the method vector with name NAME, or -1 is no such field exists. */ -static int -lookup_fnfields_1 (type, name) - tree type, name; -{ - register tree method_vec = CLASSTYPE_METHOD_VEC (type); - - if (method_vec != 0) - { - register tree *methods = &TREE_VEC_ELT (method_vec, 0); - register tree *end = TREE_VEC_END (method_vec); - -#ifdef GATHER_STATISTICS - n_calls_lookup_fnfields_1++; -#endif - if (*methods && name == constructor_name (type)) - return 0; - - while (++methods != end) - { -#ifdef GATHER_STATISTICS - n_outer_fields_searched++; -#endif - if (DECL_NAME (*methods) == name) - break; - } - if (methods != end) - return methods - &TREE_VEC_ELT (method_vec, 0); - } - - return -1; -} - -/* Starting from BASETYPE, return a TREE_BASELINK-like object - which gives the following information (in a list): - - TREE_TYPE: list of basetypes needed to get to... - TREE_VALUE: list of all functions in of given type - which have name NAME. - - No visibility information is computed by this function, - other then to adorn the list of basetypes with - TREE_VIA_PUBLIC. - - If there are two ways to find a name (two members), if COMPLAIN is - non-zero, then error_mark_node is returned, and an error message is - printed, otherwise, just an error_mark_node is returned. - - As a special case, is COMPLAIN is -1, we don't complain, and we - don't return error_mark_node, but rather the complete list of - virtuals. This is used by get_virtuals_named_this. */ -tree -lookup_fnfields (basetype_path, name, complain) - tree basetype_path, name; - int complain; -{ - int head = 0, tail = 0; - tree type, rval, rval_binfo = NULL_TREE, rvals = NULL_TREE, rval_binfo_h; - tree entry, binfo, basetype_chain, binfo_h; - int find_all = 0; - - /* rval_binfo is the binfo associated with the found member, note, - this can be set with useful information, even when rval is not - set, because it must deal with ALL members, not just function - members. It is used for ambiguity checking and the hidden - checks. Whereas rval is only set if a proper (not hidden) - function member is found. */ - - /* rval_binfo_h and binfo_h are binfo values used when we perform the - hiding checks, as virtual base classes may not be shared. The strategy - is we always go into the the binfo hierarchy owned by TYPE_BINFO of - virtual base classes, as we cross virtual base class lines. This way - we know that binfo of a virtual base class will always == itself when - found along any line. (mrs) */ - - /* For now, don't try this. */ - int protect = complain; - - /* Things for memoization. */ - char *errstr = 0; - - /* Set this to nonzero if we don't know how to compute - accurate error messages for visibility. */ - int index = MEMOIZED_HASH_FN (name); - - if (complain == -1) - { - find_all = 1; - protect = complain = 0; - } - - binfo = basetype_path; - binfo_h = binfo; - type = BINFO_TYPE (basetype_path); - - /* The memoization code is in need of maintenance. */ - if (!find_all && CLASSTYPE_MTABLE_ENTRY (type)) - { - tree tem = MEMOIZED_FNFIELDS (CLASSTYPE_MTABLE_ENTRY (type), index); - - while (tem && TREE_PURPOSE (tem) != name) - { - memoized_fields_searched[1]++; - tem = TREE_CHAIN (tem); - } - if (tem) - { - if (protect && TREE_TYPE (tem)) - { - error (TREE_STRING_POINTER (TREE_TYPE (tem)), - IDENTIFIER_POINTER (name), - TYPE_NAME_STRING (DECL_CLASS_CONTEXT (TREE_VALUE (TREE_VALUE (tem))))); - return error_mark_node; - } - if (TREE_VALUE (tem) == NULL_TREE) - { - memoized_fast_rejects[1] += 1; - return NULL_TREE; - } - else - { - /* Want to return this, but we must make sure - that visibility information is consistent. */ - tree baselink = TREE_VALUE (tem); - tree memoized_basetypes = TREE_PURPOSE (baselink); - tree these_basetypes = basetype_path; - while (memoized_basetypes && these_basetypes) - { - memoized_fields_searched[1]++; - if (TREE_VALUE (memoized_basetypes) != these_basetypes) - break; - memoized_basetypes = TREE_CHAIN (memoized_basetypes); - these_basetypes = BINFO_INHERITANCE_CHAIN (these_basetypes); - } - /* The following statement is true only when both are NULL. */ - if (memoized_basetypes == these_basetypes) - { - memoized_fast_finds[1] += 1; - return TREE_VALUE (tem); - } - /* else, we must re-find this field by hand. */ - baselink = tree_cons (basetype_path, TREE_VALUE (baselink), TREE_CHAIN (baselink)); - return baselink; - } - } - } - -#ifdef GATHER_STATISTICS - n_calls_lookup_fnfields++; -#endif - if (protect && flag_memoize_lookups && ! global_bindings_p ()) - entry = make_memoized_table_entry (type, name, 1); - else - entry = 0; - - index = lookup_fnfields_here (type, name); - if (index >= 0 || lookup_field_1 (type, name)) - { - rval_binfo = basetype_path; - rval_binfo_h = rval_binfo; - } - - if (index >= 0) - { - rval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index); - rvals = my_tree_cons (basetype_path, rval, rvals); - if (BINFO_BASETYPES (binfo) && CLASSTYPE_BASELINK_VEC (type)) - TREE_TYPE (rvals) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), index); - - if (entry) - { - TREE_VALUE (entry) = rvals; - TREE_TYPE (entry) = NULL_TREE; - } - - if (errstr && protect) - { - error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type)); - return error_mark_node; - } - return rvals; - } - rval = NULL_TREE; - - basetype_chain = CLASSTYPE_BINFO_AS_LIST (type); - TREE_VIA_PUBLIC (basetype_chain) = 1; - - /* The ambiguity check relies upon breadth first searching. */ - - search_stack = push_search_level (search_stack, &search_obstack); - BINFO_VIA_PUBLIC (basetype_path) = 1; - BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE; - binfo = basetype_path; - binfo_h = binfo; - - while (1) - { - tree binfos = BINFO_BASETYPES (binfo); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - int index; - - /* Process and/or queue base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - if (BINFO_FIELDS_MARKED (base_binfo) == 0) - { - tree btypes; - - SET_BINFO_FIELDS_MARKED (base_binfo); - btypes = my_tree_cons (NULL_TREE, base_binfo, basetype_chain); - TREE_VIA_PUBLIC (btypes) = TREE_VIA_PUBLIC (base_binfo); - TREE_VIA_PROTECTED (btypes) = TREE_VIA_PROTECTED (base_binfo); - TREE_VIA_VIRTUAL (btypes) = TREE_VIA_VIRTUAL (base_binfo); - if (TREE_VIA_VIRTUAL (base_binfo)) - btypes = tree_cons (NULL_TREE, - TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i))), - btypes); - else - btypes = tree_cons (NULL_TREE, - TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i), - btypes); - obstack_ptr_grow (&search_obstack, btypes); - tail += 1; - if (tail >= search_stack->limit) - my_friendly_abort (99); - } - } - - /* Process head of queue, if one exists. */ - if (head >= tail) - break; - - basetype_chain = search_stack->first[head++]; - binfo_h = TREE_VALUE (basetype_chain); - basetype_chain = TREE_CHAIN (basetype_chain); - basetype_path = TREE_VALUE (basetype_chain); - if (TREE_CHAIN (basetype_chain)) - BINFO_INHERITANCE_CHAIN (basetype_path) = TREE_VALUE (TREE_CHAIN (basetype_chain)); - else - BINFO_INHERITANCE_CHAIN (basetype_path) = NULL_TREE; - - binfo = basetype_path; - type = BINFO_TYPE (binfo); - - /* See if we can find NAME in TYPE. If RVAL is nonzero, - and we do find NAME in TYPE, verify that such a second - sighting is in fact legal. */ - - index = lookup_fnfields_here (type, name); - - if (index >= 0 || (lookup_field_1 (type, name)!=NULL_TREE && !find_all)) - { - if (rval_binfo && !find_all && hides (rval_binfo_h, binfo_h)) - { - /* This is ok, the member found is in rval_binfo, not - here (binfo). */ - } - else if (rval_binfo==NULL_TREE || find_all || hides (binfo_h, rval_binfo_h)) - { - /* This is ok, the member found is here (binfo), not in - rval_binfo. */ - if (index >= 0) - { - rval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index); - /* Note, rvals can only be previously set if find_all is - true. */ - rvals = my_tree_cons (basetype_path, rval, rvals); - if (TYPE_BINFO_BASETYPES (type) - && CLASSTYPE_BASELINK_VEC (type)) - TREE_TYPE (rvals) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), index); - } - else - { - /* Undo finding it before, as something else hides it. */ - rval = NULL_TREE; - rvals = NULL_TREE; - } - rval_binfo = binfo; - rval_binfo_h = binfo_h; - } - else - { - /* This is ambiguous. */ - errstr = "request for member `%s' is ambiguous"; - rvals = error_mark_node; - break; - } - } - } - { - tree *tp = search_stack->first; - tree *search_tail = tp + tail; - - while (tp < search_tail) - { - CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp))); - tp += 1; - } - } - search_stack = pop_search_level (search_stack); - - if (entry) - { - if (errstr) - { - tree error_string = my_build_string (errstr); - /* Save error message with entry. */ - TREE_TYPE (entry) = error_string; - } - else - { - /* Mark entry as having no error string. */ - TREE_TYPE (entry) = NULL_TREE; - TREE_VALUE (entry) = rvals; - } - } - - if (errstr && protect) - { - error (errstr, IDENTIFIER_POINTER (name), TYPE_NAME_STRING (type)); - rvals = error_mark_node; - } - - return rvals; -} - -/* BREADTH-FIRST SEARCH ROUTINES. */ - -/* Search a multiple inheritance hierarchy by breadth-first search. - - TYPE is an aggregate type, possibly in a multiple-inheritance hierarchy. - TESTFN is a function, which, if true, means that our condition has been met, - and its return value should be returned. - QFN, if non-NULL, is a predicate dictating whether the type should - even be queued. */ - -HOST_WIDE_INT -breadth_first_search (binfo, testfn, qfn) - tree binfo; - int (*testfn)(); - int (*qfn)(); -{ - int head = 0, tail = 0; - int rval = 0; - - search_stack = push_search_level (search_stack, &search_obstack); - - while (1) - { - tree binfos = BINFO_BASETYPES (binfo); - int n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - int i; - - /* Process and/or queue base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - - if (BINFO_MARKED (base_binfo) == 0 - && (qfn == 0 || (*qfn) (binfo, i))) - { - SET_BINFO_MARKED (base_binfo); - obstack_ptr_grow (&search_obstack, binfo); - obstack_ptr_grow (&search_obstack, (HOST_WIDE_INT) i); - tail += 2; - if (tail >= search_stack->limit) - my_friendly_abort (100); - } - } - /* Process head of queue, if one exists. */ - if (head >= tail) - { - rval = 0; - break; - } - - binfo = search_stack->first[head++]; - i = (int) search_stack->first[head++]; - if (rval = (*testfn) (binfo, i)) - break; - binfo = BINFO_BASETYPE (binfo, i); - } - { - tree *tp = search_stack->first; - tree *search_tail = tp + tail; - while (tp < search_tail) - { - tree binfo = *tp++; - int i = (HOST_WIDE_INT)(*tp++); - CLEAR_BINFO_MARKED (BINFO_BASETYPE (binfo, i)); - } - } - - search_stack = pop_search_level (search_stack); - return rval; -} - -/* Functions to use in breadth first searches. */ -typedef tree (*pft)(); -typedef int (*pfi)(); - -int tree_needs_constructor_p (binfo, i) - tree binfo; - int i; -{ - tree basetype; - my_friendly_assert (i != 0, 296); - basetype = BINFO_TYPE (BINFO_BASETYPE (binfo, i)); - return TYPE_NEEDS_CONSTRUCTOR (basetype); -} - -static tree declarator; - -static tree -get_virtuals_named_this (binfo) - tree binfo; -{ - tree fields; - - fields = lookup_fnfields (binfo, declarator, -1); - /* fields cannot be error_mark_node */ - - if (fields == 0) - return 0; - - /* Get to the function decls, and return the first virtual function - with this name, if there is one. */ - while (fields) - { - tree fndecl; - - for (fndecl = TREE_VALUE (fields); fndecl; fndecl = DECL_CHAIN (fndecl)) - if (DECL_VINDEX (fndecl)) - return fields; - fields = next_baselink (fields); - } - return NULL_TREE; -} - -static tree get_virtual_destructor (binfo, i) - tree binfo; - int i; -{ - tree type = BINFO_TYPE (binfo); - if (i >= 0) - type = BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), i)); - if (TYPE_HAS_DESTRUCTOR (type) - && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0))) - return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0); - return 0; -} - -int tree_has_any_destructor_p (binfo, i) - tree binfo; - int i; -{ - tree type = BINFO_TYPE (binfo); - if (i >= 0) - type = BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo), i)); - return TYPE_NEEDS_DESTRUCTOR (type); -} - -/* Given a class type TYPE, and a function decl FNDECL, - look for the first function the TYPE's hierarchy which - FNDECL could match as a virtual function. - - DTORP is nonzero if we are looking for a destructor. Destructors - need special treatment because they do not match by name. */ -tree -get_first_matching_virtual (binfo, fndecl, dtorp) - tree binfo, fndecl; - int dtorp; -{ - tree tmp = NULL_TREE; - - /* Breadth first search routines start searching basetypes - of TYPE, so we must perform first ply of search here. */ - if (dtorp) - { - if (tree_has_any_destructor_p (binfo, -1)) - tmp = get_virtual_destructor (binfo, -1); - - if (tmp) - { - if (get_base_distance (DECL_CONTEXT (tmp), - DECL_CONTEXT (fndecl), 0, 0) > 0) - DECL_CONTEXT (fndecl) = DECL_CONTEXT (tmp); - return tmp; - } - - tmp = (tree) breadth_first_search (binfo, - (pfi) get_virtual_destructor, - tree_has_any_destructor_p); - if (tmp) - { - if (get_base_distance (DECL_CONTEXT (tmp), - DECL_CONTEXT (fndecl), 0, 0) > 0) - DECL_CONTEXT (fndecl) = DECL_CONTEXT (tmp); - } - return tmp; - } - else - { - tree drettype, dtypes, btypes, instptr_type; - tree basetype = DECL_CLASS_CONTEXT (fndecl); - tree baselink, best = NULL_TREE; - tree name = DECL_ASSEMBLER_NAME (fndecl); - - declarator = DECL_NAME (fndecl); - if (IDENTIFIER_VIRTUAL_P (declarator) == 0) - return NULL_TREE; - - drettype = TREE_TYPE (TREE_TYPE (fndecl)); - dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); - if (DECL_STATIC_FUNCTION_P (fndecl)) - instptr_type = NULL_TREE; - else - instptr_type = TREE_TYPE (TREE_VALUE (dtypes)); - - for (baselink = get_virtuals_named_this (binfo); - baselink; baselink = next_baselink (baselink)) - { - for (tmp = TREE_VALUE (baselink); tmp; tmp = DECL_CHAIN (tmp)) - { - if (! DECL_VINDEX (tmp)) - continue; - - btypes = TYPE_ARG_TYPES (TREE_TYPE (tmp)); - if (instptr_type == NULL_TREE) - { - if (compparms (TREE_CHAIN (btypes), dtypes, 3)) - /* Caller knows to give error in this case. */ - return tmp; - return NULL_TREE; - } - - if ((TYPE_READONLY (TREE_TYPE (TREE_VALUE (btypes))) - == TYPE_READONLY (instptr_type)) - && compparms (TREE_CHAIN (btypes), TREE_CHAIN (dtypes), 3)) - { - if (IDENTIFIER_ERROR_LOCUS (name) == NULL_TREE - && ! comptypes (TREE_TYPE (TREE_TYPE (tmp)), drettype, 1)) - { - error_with_decl (fndecl, "conflicting return type specified for virtual function `%s'"); - SET_IDENTIFIER_ERROR_LOCUS (name, basetype); - } - break; - } - } - if (tmp) - { - /* If this is ambiguous, we will warn about it later. */ - if (best) - { - if (get_base_distance (DECL_CLASS_CONTEXT (best), - DECL_CLASS_CONTEXT (tmp), 0, 0) > 0) - best = tmp; - } - else - best = tmp; - } - } - if (IDENTIFIER_ERROR_LOCUS (name) == NULL_TREE - && best == NULL_TREE && warn_overloaded_virtual) - { - warning_with_decl (fndecl, - "conflicting specification deriving virtual function `%s'"); - SET_IDENTIFIER_ERROR_LOCUS (name, basetype); - } - if (best) - { - if (get_base_distance (DECL_CONTEXT (best), - DECL_CONTEXT (fndecl), 0, 0) > 0) - DECL_CONTEXT (fndecl) = DECL_CONTEXT (best); - } - return best; - } -} - -/* Return the list of virtual functions which are abstract in type TYPE. - This information is cached, and so must be built on a - non-temporary obstack. */ -tree -get_abstract_virtuals (type) - tree type; -{ - /* For each layer of base class (i.e., the first base class, and each - virtual base class from that one), modify the virtual function table - of the derived class to contain the new virtual function. - A class has as many vfields as it has virtual base classes (total). */ - tree vfields, vbases, base, tmp; - tree vfield = CLASSTYPE_VFIELD (type); - tree fcontext = vfield ? DECL_FCONTEXT (vfield) : NULL_TREE; - tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (type); - - for (vfields = CLASSTYPE_VFIELDS (type); vfields; vfields = TREE_CHAIN (vfields)) - { - int normal; - - /* This code is most likely wrong, and probably only works for single - inheritance or by accident. */ - - /* Find the right base class for this derived class, call it BASE. */ - base = VF_BASETYPE_VALUE (vfields); - if (base == type) - continue; - - /* We call this case NORMAL iff this virtual function table - pointer field has its storage reserved in this class. - This is normally the case without virtual baseclasses - or off-center multiple baseclasses. */ - normal = (base == fcontext - && (VF_BINFO_VALUE (vfields) == NULL_TREE - || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))); - - if (normal) - tmp = TREE_CHAIN (TYPE_BINFO_VIRTUALS (type)); - else - { - /* n.b.: VF_BASETYPE_VALUE (vfields) is the first basetype - that provides the virtual function table, whereas - VF_DERIVED_VALUE (vfields) is an immediate base type of TYPE - that dominates VF_BASETYPE_VALUE (vfields). The list of - vfields we want lies between these two values. */ - tree binfo = get_binfo (VF_NORMAL_VALUE (vfields), type, 0); - tmp = TREE_CHAIN (BINFO_VIRTUALS (binfo)); - } - - /* Get around dossier entry if there is one. */ - if (flag_dossier) - tmp = TREE_CHAIN (tmp); - - while (tmp) - { - tree base_pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (tmp)); - tree base_fndecl = TREE_OPERAND (base_pfn, 0); - if (DECL_ABSTRACT_VIRTUAL_P (base_fndecl)) - abstract_virtuals = tree_cons (NULL_TREE, base_fndecl, abstract_virtuals); - tmp = TREE_CHAIN (tmp); - } - } - for (vbases = CLASSTYPE_VBASECLASSES (type); vbases; vbases = TREE_CHAIN (vbases)) - { - if (! BINFO_VIRTUALS (vbases)) - continue; - - tmp = TREE_CHAIN (BINFO_VIRTUALS (vbases)); - while (tmp) - { - tree base_pfn = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (tmp)); - tree base_fndecl = TREE_OPERAND (base_pfn, 0); - if (DECL_ABSTRACT_VIRTUAL_P (base_fndecl)) - abstract_virtuals = tree_cons (NULL_TREE, base_fndecl, abstract_virtuals); - tmp = TREE_CHAIN (tmp); - } - } - return nreverse (abstract_virtuals); -} - -/* For the type TYPE, return a list of member functions available from - base classes with name NAME. The TREE_VALUE of the list is a chain of - member functions with name NAME. The TREE_PURPOSE of the list is a - basetype, or a list of base types (in reverse order) which were - traversed to reach the chain of member functions. If we reach a base - type which provides a member function of name NAME, and which has at - most one base type itself, then we can terminate the search. */ - -tree -get_baselinks (type_as_binfo_list, type, name) - tree type_as_binfo_list; - tree type, name; -{ - int head = 0, tail = 0, index; - tree rval = 0, nval = 0; - tree basetypes = type_as_binfo_list; - tree binfo = TYPE_BINFO (type); - - search_stack = push_search_level (search_stack, &search_obstack); - - while (1) - { - tree binfos = BINFO_BASETYPES (binfo); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - /* Process and/or queue base types. */ - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - tree btypes; - - btypes = hash_tree_cons (TREE_VIA_PUBLIC (base_binfo), - TREE_VIA_VIRTUAL (base_binfo), - TREE_VIA_PROTECTED (base_binfo), - NULL_TREE, base_binfo, - basetypes); - obstack_ptr_grow (&search_obstack, btypes); - search_stack->first = (tree *)obstack_base (&search_obstack); - tail += 1; - } - - dont_queue: - /* Process head of queue, if one exists. */ - if (head >= tail) - break; - - basetypes = search_stack->first[head++]; - binfo = TREE_VALUE (basetypes); - type = BINFO_TYPE (binfo); - index = lookup_fnfields_1 (type, name); - if (index >= 0) - { - nval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), index); - rval = hash_tree_cons (0, 0, 0, basetypes, nval, rval); - if (TYPE_BINFO_BASETYPES (type) == 0) - goto dont_queue; - else if (TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)) == 1) - { - if (CLASSTYPE_BASELINK_VEC (type)) - TREE_TYPE (rval) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), index); - goto dont_queue; - } - } - nval = NULL_TREE; - } - - search_stack = pop_search_level (search_stack); - return rval; -} - -tree -next_baselink (baselink) - tree baselink; -{ - tree tmp = TREE_TYPE (baselink); - baselink = TREE_CHAIN (baselink); - while (tmp) - { - /* @@ does not yet add previous base types. */ - baselink = tree_cons (TREE_PURPOSE (tmp), TREE_VALUE (tmp), - baselink); - TREE_TYPE (baselink) = TREE_TYPE (tmp); - tmp = TREE_CHAIN (tmp); - } - return baselink; -} - -/* DEPTH-FIRST SEARCH ROUTINES. */ - -/* Assign unique numbers to _CLASSTYPE members of the lattice - specified by TYPE. The root nodes are marked first; the nodes - are marked depth-fisrt, left-right. */ - -static int cid; - -/* Matrix implementing a relation from CLASSTYPE X CLASSTYPE => INT. - Relation yields 1 if C1 <= C2, 0 otherwise. */ -typedef char mi_boolean; -static mi_boolean *mi_matrix; - -/* Type for which this matrix is defined. */ -static tree mi_type; - -/* Size of the matrix for indexing purposes. */ -static int mi_size; - -/* Return nonzero if class C2 derives from class C1. */ -#define BINFO_DERIVES_FROM(C1, C2) \ - ((mi_matrix+mi_size*(BINFO_CID (C1)-1))[BINFO_CID (C2)-1]) -#define TYPE_DERIVES_FROM(C1, C2) \ - ((mi_matrix+mi_size*(CLASSTYPE_CID (C1)-1))[CLASSTYPE_CID (C2)-1]) -#define BINFO_DERIVES_FROM_STAR(C) \ - (mi_matrix+(BINFO_CID (C)-1)) - -/* This routine converts a pointer to be a pointer of an immediate - base class. The normal convert_pointer_to routine would diagnose - the conversion as ambiguous, under MI code that has the base class - as an ambiguous base class. */ -static tree -convert_pointer_to_single_level (to_type, expr) - tree to_type, expr; -{ - tree binfo_of_derived; - tree last; - - binfo_of_derived = TYPE_BINFO (TREE_TYPE (TREE_TYPE (expr))); - last = get_binfo (to_type, TREE_TYPE (TREE_TYPE (expr)), 0); - BINFO_INHERITANCE_CHAIN (last) = binfo_of_derived; - BINFO_INHERITANCE_CHAIN (binfo_of_derived) = NULL_TREE; - return build_vbase_path (PLUS_EXPR, TYPE_POINTER_TO (to_type), expr, last, 1); -} - -/* The main function which implements depth first search. - - This routine has to remember the path it walked up, when - dfs_init_vbase_pointers is the work function, as otherwise there - would be no record. */ -static void -dfs_walk (binfo, fn, qfn) - tree binfo; - void (*fn)(); - int (*qfn)(); -{ - tree binfos = BINFO_BASETYPES (binfo); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - for (i = 0; i < n_baselinks; i++) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - - if ((*qfn)(base_binfo)) - { -#define NEW_CONVERT 1 -#if NEW_CONVERT - if (fn == dfs_init_vbase_pointers) - { - /* When traversing an arbitrary MI hierarchy, we need to keep - a record of the path we took to get down to the final base - type, as otherwise there would be no record of it, and just - trying to blindly convert at the bottom would be ambiguous. - - The easiest way is to do the conversions one step at a time, - as we know we want the immediate base class at each step. - - The only special trick to converting one step at a time, - is that when we hit the last virtual base class, we must - use the SLOT value for it, and not use the normal convert - routine. We use the last virtual base class, as in our - implementation, we have pointers to all virtual base - classes in the base object. */ - - tree saved_vbase_decl_ptr_intermediate - = vbase_decl_ptr_intermediate; - - if (TREE_VIA_VIRTUAL (base_binfo)) - { - /* No need for the conversion here, as we know it is the - right type. */ - vbase_decl_ptr_intermediate = - (tree)CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (base_binfo)); - } - else - { -#ifdef CHECK_convert_pointer_to_single_level - /* This code here introduces a little software fault - tolerance It should be that case that the second - one always gets the same valid answer that the - first one gives, if the first one gives a valid - answer. - - If it doesn't, the second algorithm is at fault - and needs to be fixed. - - The first one is known to be bad and produce - error_mark_node when dealing with MI base - classes. It is the only problem supposed to be - fixed by the second. */ -#endif - tree vdpi1, vdpi2; - -#ifdef CHECK_convert_pointer_to_single_level - vdpi1 = convert_pointer_to (BINFO_TYPE (base_binfo), - vbase_decl_ptr_intermediate); -#endif - vdpi2 = convert_pointer_to_single_level (BINFO_TYPE (base_binfo), - vbase_decl_ptr_intermediate); - vbase_decl_ptr_intermediate = vdpi2; -#ifdef CHECK_convert_pointer_to_single_level - if (vdpi1 == error_mark_node && vdpi2 != vdpi1) - { - extern int errorcount; - errorcount -=2; - warning ("internal: Don't worry, be happy, I can fix tangs man. (ignore above error)"); - } - else if (simple_cst_equal (vdpi1, vdpi2) != 1) { - if (simple_cst_equal (vdpi1, vdpi2) == 0) - warning ("internal: convert_pointer_to_single_level: They are not the same, going with old algorithm"); - else - warning ("internal: convert_pointer_to_single_level: They might not be the same, going with old algorithm"); - vbase_decl_ptr_intermediate = vdpi1; - } -#endif - } - - dfs_walk (base_binfo, fn, qfn); - - vbase_decl_ptr_intermediate = saved_vbase_decl_ptr_intermediate; - } else -#endif - dfs_walk (base_binfo, fn, qfn); - } - } - - fn (binfo); -} - -/* Predicate functions which serve for dfs_walk. */ -static int numberedp (binfo) tree binfo; -{ return BINFO_CID (binfo); } -static int unnumberedp (binfo) tree binfo; -{ return BINFO_CID (binfo) == 0; } - -static int markedp (binfo) tree binfo; -{ return BINFO_MARKED (binfo); } -static int bfs_markedp (binfo, i) tree binfo; int i; -{ return BINFO_MARKED (BINFO_BASETYPE (binfo, i)); } -static int unmarkedp (binfo) tree binfo; -{ return BINFO_MARKED (binfo) == 0; } -static int bfs_unmarkedp (binfo, i) tree binfo; int i; -{ return BINFO_MARKED (BINFO_BASETYPE (binfo, i)) == 0; } -static int marked_vtable_pathp (binfo) tree binfo; -{ return BINFO_VTABLE_PATH_MARKED (binfo); } -static int bfs_marked_vtable_pathp (binfo, i) tree binfo; int i; -{ return BINFO_VTABLE_PATH_MARKED (BINFO_BASETYPE (binfo, i)); } -static int unmarked_vtable_pathp (binfo) tree binfo; -{ return BINFO_VTABLE_PATH_MARKED (binfo) == 0; } -static int bfs_unmarked_vtable_pathp (binfo, i) tree binfo; int i; -{ return BINFO_VTABLE_PATH_MARKED (BINFO_BASETYPE (binfo, i)) == 0; } -static int marked_new_vtablep (binfo) tree binfo; -{ return BINFO_NEW_VTABLE_MARKED (binfo); } -static int bfs_marked_new_vtablep (binfo, i) tree binfo; int i; -{ return BINFO_NEW_VTABLE_MARKED (BINFO_BASETYPE (binfo, i)); } -static int unmarked_new_vtablep (binfo) tree binfo; -{ return BINFO_NEW_VTABLE_MARKED (binfo) == 0; } -static int bfs_unmarked_new_vtablep (binfo, i) tree binfo; int i; -{ return BINFO_NEW_VTABLE_MARKED (BINFO_BASETYPE (binfo, i)) == 0; } - -static int dfs_search_slot_nonempty_p (binfo) tree binfo; -{ return CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (binfo)) != 0; } - -static int dfs_debug_unmarkedp (binfo) tree binfo; -{ return CLASSTYPE_DEBUG_REQUESTED (BINFO_TYPE (binfo)) == 0; } - -/* The worker functions for `dfs_walk'. These do not need to - test anything (vis a vis marking) if they are paired with - a predicate function (above). */ - -/* Assign each type within the lattice a number which is unique - in the lattice. The first number assigned is 1. */ - -static void -dfs_number (binfo) - tree binfo; -{ - BINFO_CID (binfo) = ++cid; -} - -static void -dfs_unnumber (binfo) - tree binfo; -{ - BINFO_CID (binfo) = 0; -} - -static void -dfs_mark (binfo) tree binfo; -{ SET_BINFO_MARKED (binfo); } - -static void -dfs_unmark (binfo) tree binfo; -{ CLEAR_BINFO_MARKED (binfo); } - -static void -dfs_mark_vtable_path (binfo) tree binfo; -{ SET_BINFO_VTABLE_PATH_MARKED (binfo); } - -static void -dfs_unmark_vtable_path (binfo) tree binfo; -{ CLEAR_BINFO_VTABLE_PATH_MARKED (binfo); } - -static void -dfs_mark_new_vtable (binfo) tree binfo; -{ SET_BINFO_NEW_VTABLE_MARKED (binfo); } - -static void -dfs_unmark_new_vtable (binfo) tree binfo; -{ CLEAR_BINFO_NEW_VTABLE_MARKED (binfo); } - -static void -dfs_clear_search_slot (binfo) tree binfo; -{ CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (binfo)) = 0; } - -static void -dfs_debug_mark (binfo) - tree binfo; -{ - tree t = BINFO_TYPE (binfo); - - /* Use heuristic that if there are virtual functions, - ignore until we see a non-inline virtual function. */ - tree methods = CLASSTYPE_METHOD_VEC (t); - - CLASSTYPE_DEBUG_REQUESTED (t) = 1; - - /* If interface info is known, the value of (?@@?) is correct. */ - if (methods == 0 - || ! CLASSTYPE_INTERFACE_UNKNOWN (t) - || (write_virtuals == 2 && TYPE_VIRTUAL_P (t))) - return; - - /* If debug info is requested from this context for this type, supply it. - If debug info is requested from another context for this type, - see if some third context can supply it. */ - if (current_function_decl == NULL_TREE - || DECL_CLASS_CONTEXT (current_function_decl) != t) - { - if (TREE_VEC_ELT (methods, 0)) - methods = TREE_VEC_ELT (methods, 0); - else - methods = TREE_VEC_ELT (methods, 1); - while (methods) - { - if (DECL_VINDEX (methods) - && DECL_SAVED_INSNS (methods) == 0 - && DECL_PENDING_INLINE_INFO (methods) == 0 - && DECL_ABSTRACT_VIRTUAL_P (methods) == 0) - { - /* Somebody, somewhere is going to have to define this - virtual function. When they do, they will provide - the debugging info. */ - return; - } - methods = TREE_CHAIN (methods); - } - } - /* We cannot rely on some alien method to solve our problems, - so we must write out the debug info ourselves. */ - DECL_IGNORED_P (TYPE_NAME (t)) = 0; - if (! TREE_ASM_WRITTEN (TYPE_NAME (t))) - rest_of_type_compilation (t, global_bindings_p ()); -} - -/* Attach to the type of the virtual base class, the pointer to the - virtual base class, given the global pointer vbase_decl_ptr. */ -static void -dfs_find_vbases (binfo) - tree binfo; -{ - tree binfos = BINFO_BASETYPES (binfo); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - - for (i = n_baselinks-1; i >= 0; i--) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - - if (TREE_VIA_VIRTUAL (base_binfo) - && CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (base_binfo)) == 0) - { - tree vbase = BINFO_TYPE (base_binfo); - tree binfo = binfo_member (vbase, vbase_types); - - CLASSTYPE_SEARCH_SLOT (vbase) - = (char *) build (PLUS_EXPR, TYPE_POINTER_TO (vbase), - vbase_decl_ptr, BINFO_OFFSET (binfo)); - } - } - SET_BINFO_VTABLE_PATH_MARKED (binfo); - SET_BINFO_NEW_VTABLE_MARKED (binfo); -} - -static void -dfs_init_vbase_pointers (binfo) - tree binfo; -{ - tree type = BINFO_TYPE (binfo); - tree fields = TYPE_FIELDS (type); - tree path, this_vbase_ptr; - int distance; - - CLEAR_BINFO_VTABLE_PATH_MARKED (binfo); - - /* If there is a dossier, it is the first field, though perhaps from - the base class. Otherwise, the first fields are virtual base class - pointer fields. */ - if (CLASSTYPE_DOSSIER (type) && VFIELD_NAME_P (DECL_NAME (fields))) - /* Get past vtable for the object. */ - fields = TREE_CHAIN (fields); - - if (fields == NULL_TREE - || DECL_NAME (fields) == NULL_TREE - || ! VBASE_NAME_P (DECL_NAME (fields))) - return; - -#if NEW_CONVERT - this_vbase_ptr = vbase_decl_ptr_intermediate; - - if (TYPE_POINTER_TO (type) != TREE_TYPE (this_vbase_ptr)) - my_friendly_abort (125); -#endif - -#if NEW_CONVERT == 0 - distance = get_base_distance (type, TREE_TYPE (vbase_decl), 0, &path); - if (distance == -2) - { - error ("inheritance lattice too complex below"); - } - while (path) - { - if (TREE_VIA_VIRTUAL (path)) - break; - distance -= 1; - path = BINFO_INHERITANCE_CHAIN (path); - } - - if (distance > 0) - this_vbase_ptr = convert_pointer_to (type, (tree)CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (path))); - else - this_vbase_ptr = convert_pointer_to (type, vbase_decl_ptr); - - /* This happens when it is ambiguous. */ - if (this_vbase_ptr == error_mark_node) - return; -#endif - - while (fields && DECL_NAME (fields) - && VBASE_NAME_P (DECL_NAME (fields))) - { - tree ref = build (COMPONENT_REF, TREE_TYPE (fields), - build_indirect_ref (this_vbase_ptr, 0), fields); - tree init = (tree)CLASSTYPE_SEARCH_SLOT (TREE_TYPE (TREE_TYPE (fields))); - vbase_init_result = tree_cons (binfo_member (TREE_TYPE (TREE_TYPE (fields)), - vbase_types), - build_modify_expr (ref, NOP_EXPR, init), - vbase_init_result); - fields = TREE_CHAIN (fields); - } -} - -/* Sometimes this needs to clear both VTABLE_PATH and NEW_VTABLE. Other - times, just NEW_VTABLE, but optimizer should make both with equal - efficiency (though it does not currently). */ -static void -dfs_clear_vbase_slots (binfo) - tree binfo; -{ - tree type = BINFO_TYPE (binfo); - CLASSTYPE_SEARCH_SLOT (type) = 0; - CLEAR_BINFO_VTABLE_PATH_MARKED (binfo); - CLEAR_BINFO_NEW_VTABLE_MARKED (binfo); -} - -tree -init_vbase_pointers (type, decl_ptr) - tree type; - tree decl_ptr; -{ - if (TYPE_USES_VIRTUAL_BASECLASSES (type)) - { - int old_flag = flag_this_is_variable; - tree binfo = TYPE_BINFO (type); - flag_this_is_variable = -2; - vbase_types = CLASSTYPE_VBASECLASSES (type); - vbase_decl_ptr = decl_ptr; - vbase_decl = build_indirect_ref (decl_ptr, 0); - vbase_decl_ptr_intermediate = vbase_decl_ptr; - vbase_init_result = NULL_TREE; - dfs_walk (binfo, dfs_find_vbases, unmarked_vtable_pathp); - dfs_walk (binfo, dfs_init_vbase_pointers, marked_vtable_pathp); - dfs_walk (binfo, dfs_clear_vbase_slots, marked_new_vtablep); - flag_this_is_variable = old_flag; - return vbase_init_result; - } - return 0; -} - -/* Build a COMPOUND_EXPR which when expanded will generate the code - needed to initialize all the virtual function table slots of all - the virtual baseclasses. FOR_TYPE is the type which determines the - virtual baseclasses to use; TYPE is the type of the object to which - the initialization applies. TRUE_EXP is the true object we are - initializing, and DECL_PTR is the pointer to the sub-object we - are initializing. - - CTOR_P is non-zero if the caller of this function is a top-level - constructor. It is zero when called from a destructor. When - non-zero, we can use computed offsets to store the vtables. When - zero, we must store new vtables through virtual baseclass pointers. */ - -tree -build_vbase_vtables_init (main_binfo, binfo, true_exp, decl_ptr, ctor_p) - tree main_binfo, binfo; - tree true_exp, decl_ptr; - int ctor_p; -{ - tree for_type = BINFO_TYPE (main_binfo); - tree type = BINFO_TYPE (binfo); - if (TYPE_USES_VIRTUAL_BASECLASSES (type)) - { - int old_flag = flag_this_is_variable; - tree vtable_init_result = NULL_TREE; - tree vbases = CLASSTYPE_VBASECLASSES (type); - - vbase_types = CLASSTYPE_VBASECLASSES (for_type); - vbase_decl_ptr = true_exp ? build_unary_op (ADDR_EXPR, true_exp, 0) : decl_ptr; - vbase_decl = true_exp ? true_exp : build_indirect_ref (decl_ptr, 0); - - if (ctor_p) - { - /* This is an object of type IN_TYPE, */ - flag_this_is_variable = -2; - dfs_walk (main_binfo, dfs_find_vbases, unmarked_new_vtablep); - } - - /* Initialized with vtables of type TYPE. */ - while (vbases) - { - /* This time through, not every class's vtable - is going to be initialized. That is, we only initialize - the "last" vtable pointer. */ - - if (CLASSTYPE_VSIZE (BINFO_TYPE (vbases))) - { - tree addr; - tree vtbl = BINFO_VTABLE (vbases); - tree init = build_unary_op (ADDR_EXPR, vtbl, 0); - assemble_external (vtbl); - TREE_USED (vtbl) = 1; - - if (ctor_p == 0) - addr = convert_pointer_to (vbases, vbase_decl_ptr); - else - addr = (tree)CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (vbases)); - - if (addr) - { - tree ref = build_vfield_ref (build_indirect_ref (addr, 0), - BINFO_TYPE (vbases)); - init = convert_force (TREE_TYPE (ref), init); - vtable_init_result = tree_cons (NULL_TREE, build_modify_expr (ref, NOP_EXPR, init), - vtable_init_result); - } - } - vbases = TREE_CHAIN (vbases); - } - - dfs_walk (binfo, dfs_clear_vbase_slots, marked_new_vtablep); - - flag_this_is_variable = old_flag; - if (vtable_init_result) - return build_compound_expr (vtable_init_result); - } - return error_mark_node; -} - -void -clear_search_slots (type) - tree type; -{ - dfs_walk (TYPE_BINFO (type), - dfs_clear_search_slot, dfs_search_slot_nonempty_p); -} - -static void -dfs_get_vbase_types (binfo) - tree binfo; -{ - int i; - tree binfos = BINFO_BASETYPES (binfo); - tree type = BINFO_TYPE (binfo); - tree these_vbase_types = CLASSTYPE_VBASECLASSES (type); - - if (these_vbase_types) - { - while (these_vbase_types) - { - tree this_type = BINFO_TYPE (these_vbase_types); - - /* We really need to start from a fresh copy of this - virtual basetype! CLASSTYPE_MARKED2 is the shortcut - for BINFO_VBASE_MARKED. */ - if (! CLASSTYPE_MARKED2 (this_type)) - { - vbase_types = make_binfo (integer_zero_node, - this_type, - TYPE_BINFO_VTABLE (this_type), - TYPE_BINFO_VIRTUALS (this_type), - vbase_types); - TREE_VIA_VIRTUAL (vbase_types) = 1; - SET_CLASSTYPE_MARKED2 (this_type); - } - these_vbase_types = TREE_CHAIN (these_vbase_types); - } - } - else for (i = binfos ? TREE_VEC_LENGTH (binfos)-1 : -1; i >= 0; i--) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - if (TREE_VIA_VIRTUAL (base_binfo) && ! BINFO_VBASE_MARKED (base_binfo)) - { - vbase_types = make_binfo (integer_zero_node, BINFO_TYPE (base_binfo), - BINFO_VTABLE (base_binfo), - BINFO_VIRTUALS (base_binfo), vbase_types); - TREE_VIA_VIRTUAL (vbase_types) = 1; - SET_BINFO_VBASE_MARKED (base_binfo); - } - } - SET_BINFO_MARKED (binfo); -} - -/* Some virtual baseclasses might be virtual baseclasses for - other virtual baseclasses. We sort the virtual baseclasses - topologically: in the list returned, the first virtual base - classes have no virtual baseclasses themselves, and any entry - on the list has no dependency on virtual base classes later in the - list. */ -tree -get_vbase_types (type) - tree type; -{ - tree ordered_vbase_types = NULL_TREE, prev, next; - tree vbases; - - vbase_types = NULL_TREE; - dfs_walk (TYPE_BINFO (type), dfs_get_vbase_types, unmarkedp); - dfs_walk (TYPE_BINFO (type), dfs_unmark, markedp); - - while (vbase_types) - { - /* Now sort these types. This is essentially a bubble merge. */ - - /* Farm out virtual baseclasses which have no marked ancestors. */ - for (vbases = vbase_types, prev = NULL_TREE; - vbases; vbases = next) - { - next = TREE_CHAIN (vbases); - /* If VBASES does not have any vbases itself, or it's - topologically safe, it goes into the sorted list. */ - if (! CLASSTYPE_VBASECLASSES (BINFO_TYPE (vbases)) - || BINFO_VBASE_MARKED (vbases) == 0) - { - if (prev) - TREE_CHAIN (prev) = TREE_CHAIN (vbases); - else - vbase_types = TREE_CHAIN (vbases); - TREE_CHAIN (vbases) = NULL_TREE; - ordered_vbase_types = chainon (ordered_vbase_types, vbases); - CLEAR_BINFO_VBASE_MARKED (vbases); - } - else - prev = vbases; - } - - /* Now unmark types all of whose ancestors are now on the - `ordered_vbase_types' list. */ - for (vbases = vbase_types; vbases; vbases = TREE_CHAIN (vbases)) - { - /* If all our virtual baseclasses are unmarked, ok. */ - tree t = CLASSTYPE_VBASECLASSES (BINFO_TYPE (vbases)); - while (t && (BINFO_VBASE_MARKED (t) == 0 - || ! CLASSTYPE_VBASECLASSES (BINFO_TYPE (t)))) - t = TREE_CHAIN (t); - if (t == NULL_TREE) - CLEAR_BINFO_VBASE_MARKED (vbases); - } - } - - return ordered_vbase_types; -} - -static void -dfs_record_inheritance (binfo) - tree binfo; -{ - tree binfos = BINFO_BASETYPES (binfo); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - mi_boolean *derived_row = BINFO_DERIVES_FROM_STAR (binfo); - - for (i = n_baselinks-1; i >= 0; i--) - { - int j; - tree base_binfo = TREE_VEC_ELT (binfos, i); - tree baseclass = BINFO_TYPE (base_binfo); - mi_boolean *base_row = BINFO_DERIVES_FROM_STAR (base_binfo); - - /* Don't search if there's nothing there! MI_SIZE can be - zero as a result of parse errors. */ - if (TYPE_BINFO_BASETYPES (baseclass) && mi_size > 0) - for (j = mi_size*(CLASSTYPE_CID (baseclass)-1); j >= 0; j -= mi_size) - derived_row[j] |= base_row[j]; - TYPE_DERIVES_FROM (baseclass, BINFO_TYPE (binfo)) = 1; - } - - SET_BINFO_MARKED (binfo); -} - -/* Given a _CLASSTYPE node in a multiple inheritance lattice, - convert the lattice into a simple relation such that, - given to CIDs, C1 and C2, one can determine if C1 <= C2 - or C2 <= C1 or C1 <> C2. - - Once constructed, we walk the lattice depth fisrt, - applying various functions to elements as they are encountered. - - We use xmalloc here, in case we want to randomly free these tables. */ - -#define SAVE_MI_MATRIX - -void -build_mi_matrix (type) - tree type; -{ - tree binfo = TYPE_BINFO (type); - cid = 0; - -#ifdef SAVE_MI_MATRIX - if (CLASSTYPE_MI_MATRIX (type)) - { - mi_size = CLASSTYPE_N_SUPERCLASSES (type) + CLASSTYPE_N_VBASECLASSES (type); - mi_matrix = CLASSTYPE_MI_MATRIX (type); - mi_type = type; - dfs_walk (binfo, dfs_number, unnumberedp); - return; - } -#endif - - mi_size = CLASSTYPE_N_SUPERCLASSES (type) + CLASSTYPE_N_VBASECLASSES (type); - mi_matrix = (char *)xmalloc ((mi_size+1) * (mi_size+1)); - mi_type = type; - bzero (mi_matrix, mi_size * mi_size); - dfs_walk (binfo, dfs_number, unnumberedp); - dfs_walk (binfo, dfs_record_inheritance, unmarkedp); - dfs_walk (binfo, dfs_unmark, markedp); -} - -void -free_mi_matrix () -{ - dfs_walk (TYPE_BINFO (mi_type), dfs_unnumber, numberedp); - -#ifdef SAVE_MI_MATRIX - CLASSTYPE_MI_MATRIX (mi_type) = mi_matrix; -#else - free (mi_matrix); - mi_size = 0; - cid = 0; -#endif -} - -/* Local variables for detecting ambiguities of virtual functions - when two or more classes are joined at a multiple inheritance - seam. */ -typedef struct -{ - tree decl; - tree args; - tree ptr; -} mi_ventry; -static mi_ventry *mi_vmatrix; -static int *mi_vmax; -static int mi_vrows, mi_vcols; -#define MI_VMATRIX(ROW,COL) ((mi_vmatrix + (ROW)*mi_vcols)[COL]) - -/* Build a table of virtual functions for a multiple-inheritance - structure. Here, there are N base classes, and at most - M entries per class. - - This function does nothing if N is 0 or 1. */ -void -build_mi_virtuals (rows, cols) - int rows, cols; -{ - if (rows < 2 || cols == 0) - return; - mi_vrows = rows; - mi_vcols = cols; - mi_vmatrix = (mi_ventry *)xmalloc ((rows+1) * cols * sizeof (mi_ventry)); - mi_vmax = (int *)xmalloc ((rows+1) * sizeof (int)); - - bzero (mi_vmax, rows * sizeof (int)); - - /* Row indices start at 1, so adjust this. */ - mi_vmatrix -= cols; - mi_vmax -= 1; -} - -/* Comparison function for ordering virtual function table entries. */ -static int -rank_mi_virtuals (v1, v2) - mi_ventry *v1, *v2; -{ - tree p1, p2; - int i; - - i = (long) (DECL_NAME (v1->decl)) - (long) (DECL_NAME (v2->decl)); - if (i) - return i; - p1 = v1->args; - p2 = v2->args; - - if (p1 == p2) - return 0; - - while (p1 && p2) - { - i = ((long) (TREE_VALUE (p1)) - (long) (TREE_VALUE (p2))); - if (i) - return i; - - if (TREE_CHAIN (p1)) - { - if (! TREE_CHAIN (p2)) - return 1; - p1 = TREE_CHAIN (p1); - p2 = TREE_CHAIN (p2); - } - else if (TREE_CHAIN (p2)) - return -1; - else - { - /* When matches of argument lists occur, pick lowest - address to keep searching time to a minimum on - later passes--like hashing, only different. - *MUST BE STABLE*. */ - if ((long) (v2->args) < (long) (v1->args)) - v1->args = v2->args; - else - v2->args = v1->args; - return 0; - } - } - return 0; -} - -/* Install the virtuals functions got from the initializer VIRTUALS to - the table at index ROW. */ -void -add_mi_virtuals (row, virtuals) - int row; - tree virtuals; -{ - int col = 0; - - if (mi_vmatrix == 0) - return; - while (virtuals) - { - tree decl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0); - MI_VMATRIX (row, col).decl = decl; - MI_VMATRIX (row, col).args = FUNCTION_ARG_CHAIN (decl); - MI_VMATRIX (row, col).ptr = TREE_VALUE (virtuals); - virtuals = TREE_CHAIN (virtuals); - col += 1; - } - mi_vmax[row] = col; - - qsort (mi_vmatrix + row * mi_vcols, - col, - sizeof (mi_ventry), - rank_mi_virtuals); -} - -/* If joining two types results in an ambiguity in the virtual - function table, report such here. */ -void -report_ambiguous_mi_virtuals (rows, type) - int rows; - tree type; -{ - int *mi_vmin; - int row1, col1, row, col; - - if (mi_vmatrix == 0) - return; - - /* Now virtuals are all sorted, so we merge to find ambiguous cases. */ - mi_vmin = (int *)alloca ((rows+1) * sizeof (int)); - bzero (mi_vmin, rows * sizeof (int)); - - /* adjust. */ - mi_vmin -= 1; - - /* For each base class with virtual functions (and this includes views - of the virtual baseclasses from different base classes), see that - each virtual function in that base class has a unique meet. - - When the column loop is finished, THIS_DECL is in fact the meet. - If that value does not appear in the virtual function table for - the row, install it. This happens when that virtual function comes - from a virtual baseclass, or a non-leftmost baseclass. */ - - for (row1 = 1; row1 < rows; row1++) - { - tree this_decl = 0; - - for (col1 = mi_vmax[row1]-1; col1 >= mi_vmin[row1]; col1--) - { - tree these_args = MI_VMATRIX (row1, col1).args; - tree this_context; - - this_decl = MI_VMATRIX (row1, col1).decl; - if (this_decl == 0) - continue; - this_context = TYPE_BINFO (DECL_CLASS_CONTEXT (this_decl)); - - if (this_context != TYPE_BINFO (type)) - this_context = get_binfo (this_context, type, 0); - - for (row = row1+1; row <= rows; row++) - for (col = mi_vmax[row]-1; col >= mi_vmin[row]; col--) - { - mi_ventry this_entry; - - if (MI_VMATRIX (row, col).decl == 0) - continue; - - this_entry.decl = this_decl; - this_entry.args = these_args; - this_entry.ptr = MI_VMATRIX (row1, col1).ptr; - if (rank_mi_virtuals (&this_entry, &MI_VMATRIX (row, col)) == 0) - { - /* They are equal. There are four possibilities: - - (1) Derived class is defining this virtual function. - (2) Two paths to the same virtual function in the - same base class. - (3) A path to a virtual function declared in one base - class, and another path to a virtual function in a - base class of the base class. - (4) Two paths to the same virtual function in different - base classes. - - The first three cases are ok (non-ambiguous). */ - - tree that_context, tmp; - int this_before_that; - - if (type == BINFO_TYPE (this_context)) - /* case 1. */ - goto ok; - that_context = get_binfo (DECL_CLASS_CONTEXT (MI_VMATRIX (row, col).decl), type, 0); - if (that_context == this_context) - /* case 2. */ - goto ok; - if (that_context != NULL_TREE) - { - tmp = get_binfo (that_context, this_context, 0); - this_before_that = (that_context != tmp); - if (this_before_that == 0) - /* case 3a. */ - goto ok; - tmp = get_binfo (this_context, that_context, 0); - this_before_that = (this_context == tmp); - if (this_before_that != 0) - /* case 3b. */ - goto ok; - - /* case 4. */ - /* These two are not hard errors, but could be - symptoms of bad code. The resultant code - the compiler generates needs to be checked. - (mrs) */ -#if 0 - error_with_decl (MI_VMATRIX (row, col).decl, "ambiguous virtual function `%s'"); - error_with_decl (this_decl, "ambiguating function `%s' (joined by type `%s')", IDENTIFIER_POINTER (current_class_name)); -#endif - } - ok: - MI_VMATRIX (row, col).decl = 0; - - /* Let zeros propagate. */ - if (col == mi_vmax[row]-1) - { - int i = col; - while (i >= mi_vmin[row] - && MI_VMATRIX (row, i).decl == 0) - i--; - mi_vmax[row] = i+1; - } - else if (col == mi_vmin[row]) - { - int i = col; - while (i < mi_vmax[row] - && MI_VMATRIX (row, i).decl == 0) - i++; - mi_vmin[row] = i; - } - } - } - } - } - free (mi_vmatrix + mi_vcols); - mi_vmatrix = 0; - free (mi_vmax + 1); - mi_vmax = 0; -} - -/* If we want debug info for a type TYPE, make sure all its base types - are also marked as being potentially interesting. This avoids - the problem of not writing any debug info for intermediate basetypes - that have abstract virtual functions. */ - -void -note_debug_info_needed (type) - tree type; -{ - dfs_walk (TYPE_BINFO (type), dfs_debug_mark, dfs_debug_unmarkedp); -} - -/* Subroutines of push_class_decls (). */ - -/* Add the instance variables which this class contributed to the - current class binding contour. When a redefinition occurs, - if the redefinition is strictly within a single inheritance path, - we just overwrite (in the case of a data field) or - cons (in the case of a member function) the old declaration with - the new. If the fields are not within a single inheritance path, - we must cons them in either case. */ - -static void -dfs_pushdecls (binfo) - tree binfo; -{ - tree type = BINFO_TYPE (binfo); - tree fields, *methods, *end; - tree method_vec; - - for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields)) - { - /* Unmark so that if we are in a constructor, and then find that - this field was initialized by a base initializer, - we can emit an error message. */ - if (TREE_CODE (fields) == FIELD_DECL) - TREE_USED (fields) = 0; - - if (DECL_NAME (fields) == NULL_TREE - && TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE) - { - dfs_pushdecls (TYPE_BINFO (TREE_TYPE (fields))); - continue; - } - if (TREE_CODE (fields) != TYPE_DECL) - { - DECL_PUBLIC (fields) = 0; - DECL_PROTECTED (fields) = 0; - DECL_PRIVATE (fields) = 0; - } - - if (DECL_NAME (fields)) - { - tree value = IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)); - if (value) - { - tree context; - - /* Possible ambiguity. If its defining type(s) - is (are all) derived from us, no problem. */ - - if (TREE_CODE (value) != TREE_LIST) - { - context = DECL_CLASS_CONTEXT (value); - - if (context && (context == type - || TYPE_DERIVES_FROM (context, type))) - value = fields; - else - value = tree_cons (NULL_TREE, fields, - build_tree_list (NULL_TREE, value)); - } - else - { - /* All children may derive from us, in which case - there is no problem. Otherwise, we have to - keep lists around of what the ambiguities might be. */ - tree values; - int problem = 0; - - for (values = value; values; values = TREE_CHAIN (values)) - { - tree sub_values = TREE_VALUE (values); - - if (TREE_CODE (sub_values) == TREE_LIST) - { - for (; sub_values; sub_values = TREE_CHAIN (sub_values)) - { - context = DECL_CLASS_CONTEXT (TREE_VALUE (sub_values)); - - if (! TYPE_DERIVES_FROM (context, type)) - { - value = tree_cons (NULL_TREE, TREE_VALUE (values), value); - problem = 1; - break; - } - } - } - else - { - context = DECL_CLASS_CONTEXT (sub_values); - - if (! TYPE_DERIVES_FROM (context, type)) - { - value = tree_cons (NULL_TREE, values, value); - problem = 1; - break; - } - } - } - if (! problem) value = fields; - } - - /* Mark this as a potentially ambiguous member. */ - if (TREE_CODE (value) == TREE_LIST) - { - /* Leaving TREE_TYPE blank is intentional. - We cannot use `error_mark_node' (lookup_name) - or `unknown_type_node' (all member functions use this). */ - TREE_NONLOCAL_FLAG (value) = 1; - } - - IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = value; - } - else IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = fields; - } - } - - method_vec = CLASSTYPE_METHOD_VEC (type); - if (method_vec != 0) - { - /* Farm out constructors and destructors. */ - methods = &TREE_VEC_ELT (method_vec, 1); - end = TREE_VEC_END (method_vec); - - /* This does not work for multiple inheritance yet. */ - while (methods != end) - { - /* This will cause lookup_name to return a pointer - to the tree_list of possible methods of this name. - If the order is a problem, we can nreverse them. */ - tree tmp; - tree old = IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)); - - if (old && TREE_CODE (old) == TREE_LIST) - tmp = tree_cons (DECL_NAME (*methods), *methods, old); - else - { - /* Only complain if we shadow something we can access. */ - if (old && (DECL_CLASS_CONTEXT (old) == current_class_type - || ! TREE_PRIVATE (old))) - /* Should figure out visibility more accurately. */ - warning ("shadowing member `%s' with member function", - IDENTIFIER_POINTER (DECL_NAME (*methods))); - tmp = build_tree_list (DECL_NAME (*methods), *methods); - } - - TREE_TYPE (tmp) = unknown_type_node; -#if 0 - TREE_OVERLOADED (tmp) = DECL_OVERLOADED (*methods); -#endif - TREE_NONLOCAL_FLAG (tmp) = 1; - IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = tmp; - - tmp = *methods; - while (tmp != 0) - { - DECL_PUBLIC (tmp) = 0; - DECL_PROTECTED (tmp) = 0; - DECL_PRIVATE (tmp) = 0; - tmp = DECL_CHAIN (tmp); - } - - methods++; - } - } - SET_BINFO_MARKED (binfo); -} - -/* Consolidate unique (by name) member functions. */ -static void -dfs_compress_decls (binfo) - tree binfo; -{ - tree type = BINFO_TYPE (binfo); - tree method_vec = CLASSTYPE_METHOD_VEC (type); - - if (method_vec != 0) - { - /* Farm out constructors and destructors. */ - tree *methods = &TREE_VEC_ELT (method_vec, 1); - tree *end = TREE_VEC_END (method_vec); - - for (; methods != end; methods++) - { - tree tmp = IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)); - - /* This was replaced in scope by somebody else. Just leave it - alone. */ - if (TREE_CODE (tmp) != TREE_LIST) - continue; - - if (TREE_CHAIN (tmp) == NULL_TREE - && TREE_VALUE (tmp) - && DECL_CHAIN (TREE_VALUE (tmp)) == NULL_TREE) - { - IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = TREE_VALUE (tmp); - } - } - } - CLEAR_BINFO_MARKED (binfo); -} - -/* When entering the scope of a class, we cache all of the - fields that that class provides within its inheritance - lattice. Where ambiguities result, we mark them - with `error_mark_node' so that if they are encountered - without explicit qualification, we can emit an error - message. */ -void -push_class_decls (type) - tree type; -{ - tree id; - struct obstack *ambient_obstack = current_obstack; - -#if 0 - tree tags = CLASSTYPE_TAGS (type); - - while (tags) - { - tree code_type_node; - tree tag; - - switch (TREE_CODE (TREE_VALUE (tags))) - { - case ENUMERAL_TYPE: - code_type_node = enum_type_node; - break; - case RECORD_TYPE: - code_type_node = record_type_node; - break; - case CLASS_TYPE: - code_type_node = class_type_node; - break; - case UNION_TYPE: - code_type_node = union_type_node; - break; - default: - my_friendly_abort (297); - } - tag = xref_tag (code_type_node, TREE_PURPOSE (tags), - TYPE_BINFO_BASETYPE (TREE_VALUE (tags), 0)); -#if 0 /* not yet, should get fixed properly later */ - pushdecl (make_type_decl (TREE_PURPOSE (tags), TREE_VALUE (tags))); -#else - pushdecl (build_decl (TYPE_DECL, TREE_PURPOSE (tags), TREE_VALUE (tags))); -#endif - } -#endif - - current_obstack = &bridge_obstack; - search_stack = push_search_level (search_stack, &bridge_obstack); - - id = TYPE_IDENTIFIER (type); - if (IDENTIFIER_TEMPLATE (id) != 0) - { -#if 0 - tree tmpl = IDENTIFIER_TEMPLATE (id); - push_template_decls (DECL_ARGUMENTS (TREE_PURPOSE (tmpl)), - TREE_VALUE (tmpl), 1); -#endif - overload_template_name (id, 0); - } - - /* Push class fields into CLASS_VALUE scope, and mark. */ - dfs_walk (TYPE_BINFO (type), dfs_pushdecls, unmarkedp); - - /* Compress fields which have only a single entry - by a given name, and unmark. */ - dfs_walk (TYPE_BINFO (type), dfs_compress_decls, markedp); - current_obstack = ambient_obstack; -} - -static void -dfs_popdecls (binfo) - tree binfo; -{ - tree type = BINFO_TYPE (binfo); - tree fields = TYPE_FIELDS (type); - tree method_vec = CLASSTYPE_METHOD_VEC (type); - - while (fields) - { - if (DECL_NAME (fields) == NULL_TREE - && TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE) - { - dfs_popdecls (TYPE_BINFO (TREE_TYPE (fields))); - } - else if (DECL_NAME (fields)) - IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) = NULL_TREE; - fields = TREE_CHAIN (fields); - } - if (method_vec != 0) - { - tree *methods = &TREE_VEC_ELT (method_vec, 0); - tree *end = TREE_VEC_END (method_vec); - - /* Clear out ctors and dtors. */ - if (*methods) - IDENTIFIER_CLASS_VALUE (TYPE_IDENTIFIER (type)) = NULL_TREE; - - for (methods += 1; methods != end; methods++) - IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods)) = NULL_TREE; - } - - SET_BINFO_MARKED (binfo); -} - -void -pop_class_decls (type) - tree type; -{ - tree binfo = TYPE_BINFO (type); - - /* Clear out the IDENTIFIER_CLASS_VALUE which this - class may have occupied, and mark. */ - dfs_walk (binfo, dfs_popdecls, unmarkedp); - - /* Unmark. */ - dfs_walk (binfo, dfs_unmark, markedp); - -#if 0 - tmpl = IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (type)); - if (tmpl != 0) - pop_template_decls (DECL_ARGUMENTS (TREE_PURPOSE (tmpl)), - TREE_VALUE (tmpl), 1); -#endif - - search_stack = pop_search_level (search_stack); -} - -/* Given a base type PARENT, and a derived type TYPE, build - a name which distinguishes exactly the PARENT member of TYPE's type. - - FORMAT is a string which controls how sprintf formats the name - we have generated. - - For example, given - - class A; class B; class C : A, B; - - it is possible to distinguish "A" from "C's A". And given - - class L; - class A : L; class B : L; class C : A, B; - - it is possible to distinguish "L" from "A's L", and also from - "C's L from A". - - Make sure to use the DECL_ASSEMBLER_NAME of the TYPE_NAME of the - type, as template have DECL_NAMEs like: X<int>, whereas the - DECL_ASSEMBLER_NAME is set to be something the assembler can handle. - */ -tree -build_type_pathname (format, parent, type) - char *format; - tree parent, type; -{ - extern struct obstack temporary_obstack; - char *first, *base, *name; - int i; - tree id; - - parent = TYPE_MAIN_VARIANT (parent); - - /* Remember where to cut the obstack to. */ - first = obstack_base (&temporary_obstack); - - /* Put on TYPE+PARENT. */ - obstack_grow (&temporary_obstack, - TYPE_ASSEMBLER_NAME_STRING (type), - TYPE_ASSEMBLER_NAME_LENGTH (type)); -#ifdef JOINER - obstack_1grow (&temporary_obstack, JOINER); -#else - obstack_1grow (&temporary_obstack, '_'); -#endif - obstack_grow0 (&temporary_obstack, - TYPE_ASSEMBLER_NAME_STRING (parent), - TYPE_ASSEMBLER_NAME_LENGTH (parent)); - i = obstack_object_size (&temporary_obstack); - base = obstack_base (&temporary_obstack); - obstack_finish (&temporary_obstack); - - /* Put on FORMAT+TYPE+PARENT. */ - obstack_blank (&temporary_obstack, strlen (format) + i + 1); - name = obstack_base (&temporary_obstack); - sprintf (name, format, base); - id = get_identifier (name); - obstack_free (&temporary_obstack, first); - - return id; -} - -static int -bfs_unmark_finished_struct (binfo, i) - tree binfo; - int i; -{ - if (i >= 0) - binfo = BINFO_BASETYPE (binfo, i); - - if (BINFO_NEW_VTABLE_MARKED (binfo)) - { - tree decl, context; - - if (TREE_VIA_VIRTUAL (binfo)) - binfo = binfo_member (BINFO_TYPE (binfo), - CLASSTYPE_VBASECLASSES (current_class_type)); - - decl = BINFO_VTABLE (binfo); - context = DECL_CONTEXT (decl); - DECL_CONTEXT (decl) = 0; - if (write_virtuals >= 0 - && DECL_INITIAL (decl) != BINFO_VIRTUALS (binfo)) - DECL_INITIAL (decl) = build_nt (CONSTRUCTOR, NULL_TREE, - BINFO_VIRTUALS (binfo)); - finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0); - DECL_CONTEXT (decl) = context; - } - CLEAR_BINFO_VTABLE_PATH_MARKED (binfo); - CLEAR_BINFO_NEW_VTABLE_MARKED (binfo); - return 0; -} - -void -unmark_finished_struct (type) - tree type; -{ - tree binfo = TYPE_BINFO (type); - bfs_unmark_finished_struct (binfo, -1); - breadth_first_search (binfo, bfs_unmark_finished_struct, bfs_marked_vtable_pathp); -} - -void -print_search_statistics () -{ -#ifdef GATHER_STATISTICS - if (flag_memoize_lookups) - { - fprintf (stderr, "%d memoized contexts saved\n", - n_contexts_saved); - fprintf (stderr, "%d local tree nodes made\n", my_tree_node_counter); - fprintf (stderr, "%d local hash nodes made\n", my_memoized_entry_counter); - fprintf (stderr, "fields statistics:\n"); - fprintf (stderr, " memoized finds = %d; rejects = %d; (searches = %d)\n", - memoized_fast_finds[0], memoized_fast_rejects[0], - memoized_fields_searched[0]); - fprintf (stderr, " memoized_adds = %d\n", memoized_adds[0]); - fprintf (stderr, "fnfields statistics:\n"); - fprintf (stderr, " memoized finds = %d; rejects = %d; (searches = %d)\n", - memoized_fast_finds[1], memoized_fast_rejects[1], - memoized_fields_searched[1]); - fprintf (stderr, " memoized_adds = %d\n", memoized_adds[1]); - } - fprintf (stderr, "%d fields searched in %d[%d] calls to lookup_field[_1]\n", - n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1); - fprintf (stderr, "%d fnfields searched in %d calls to lookup_fnfields\n", - n_outer_fields_searched, n_calls_lookup_fnfields); - fprintf (stderr, "%d calls to get_base_type\n", n_calls_get_base_type); -#else - fprintf (stderr, "no search statistics\n"); -#endif -} - -void -init_search_processing () -{ - gcc_obstack_init (&search_obstack); - gcc_obstack_init (&type_obstack); - gcc_obstack_init (&type_obstack_entries); - gcc_obstack_init (&bridge_obstack); - - /* This gives us room to build our chains of basetypes, - whether or not we decide to memoize them. */ - type_stack = push_type_level (0, &type_obstack); - _vptr_name = get_identifier ("_vptr"); -} - -void -reinit_search_statistics () -{ - my_memoized_entry_counter = 0; - memoized_fast_finds[0] = 0; - memoized_fast_finds[1] = 0; - memoized_adds[0] = 0; - memoized_adds[1] = 0; - memoized_fast_rejects[0] = 0; - memoized_fast_rejects[1] = 0; - memoized_fields_searched[0] = 0; - memoized_fields_searched[1] = 0; - n_fields_searched = 0; - n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0; - n_calls_lookup_fnfields = 0, n_calls_lookup_fnfields_1 = 0; - n_calls_get_base_type = 0; - n_outer_fields_searched = 0; - n_contexts_saved = 0; -} |