mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-01-12 07:34:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

search.c: Tear out all mi_matrix and memoize code.

Browse Source 
* search.c: Tear out all mi_matrix and memoize code.
	(lookup_field, lookup_fnfields): Use scratch_tree_cons.
	* lang-options.h: Remove documentation for -fhandle-exceptions,
	-fmemoize-lookups and -fsave-memoized.
	* cp-tree.h: Lose mi_matrix and memoize support.
	* decl2.c: Ignore -fmemoize-lookups and -fsave-memoized.
	* class.c: Lose struct class_level.
	(pushclass, popclass): Lose memoize support.
	* init.c (build_offset_ref): Likewise.

From-SVN: r22025
This commit is contained in:
Jason Merrill 1998-08-27 17:33:35 +00:00 committed by Jason Merrill
parent dfbcd65a01
commit e907984f30
8 changed files with 35 additions and 735 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gcc/cp/ChangeLog
View File

@ -1,5 +1,15 @@
1998-08-27 Jason Merrill <jason@yorick.cygnus.com>
* search.c: Tear out all mi_matrix and memoize code.
(lookup_field, lookup_fnfields): Use scratch_tree_cons.
* lang-options.h: Remove documentation for -fhandle-exceptions,
-fmemoize-lookups and -fsave-memoized.
* cp-tree.h: Lose mi_matrix and memoize support.
* decl2.c: Ignore -fmemoize-lookups and -fsave-memoized.
* class.c: Lose struct class_level.
(pushclass, popclass): Lose memoize support.
* init.c (build_offset_ref): Likewise.
Never change BINFO_INHERITANCE_CHAIN.
* init.c (emit_base_init): Change modification of
BINFO_INHERITANCE_CHAIN to an assert.

28
gcc/cp/class.c
View File

@ -48,31 +48,6 @@ static tree *current_class_base, *current_class_stack;
static int current_class_stacksize;
int current_class_depth;
struct class_level
{
/* The previous class level. */
struct class_level *level_chain;
/* The class instance variable, as a PARM_DECL. */
tree decl;
/* The class instance variable, as an object. */
tree object;
/* The virtual function table pointer
for the class instance variable. */
tree vtable_decl;
/* Name of the current class. */
tree name;
/* Type of the current class. */
tree type;
/* Flags for this class level. */
int this_is_variable;
int memoized_lookups;
int save_memoized;
int unused;
};
/* The current_class_ptr is the pointer to the current class.
current_class_ref is the actual current class. */
tree current_class_ptr, current_class_ref;
@ -4627,7 +4602,6 @@ pushclass (type, modify)
int modify;
{
type = TYPE_MAIN_VARIANT (type);
push_memoized_context (type, modify);
current_class_depth++;
*current_class_stack++ = current_class_name;
@ -4776,8 +4750,6 @@ popclass (modify)
current_class_type = *--current_class_stack;
current_class_name = *--current_class_stack;
pop_memoized_context (modify);
ret:
;
}

35
gcc/cp/cp-tree.h
View File

@ -621,9 +621,6 @@ struct lang_type
unsigned dummy : 11;
} type_flags;
#ifdef MI_MATRIX
int cid;
#endif
int n_ancestors;
int n_vancestors;
int vsize;
@ -635,7 +632,6 @@ struct lang_type
union tree_node *vbases;
union tree_node *tags;
char *memoized_table_entry;
union tree_node *search_slot;
@ -651,10 +647,6 @@ struct lang_type
union tree_node *binfo_as_list;
union tree_node *friend_classes;
#ifdef MI_MATRIX
char *mi_matrix;
#endif
union tree_node *rtti;
union tree_node *methods;
@ -867,11 +859,6 @@ struct lang_type
which uses this must define what exactly this slot is used for. */
#define CLASSTYPE_SEARCH_SLOT(NODE) (TYPE_LANG_SPECIFIC(NODE)->search_slot)
/* Entry for keeping memoization tables for this type to
hopefully speed up search routines. Since it is a pointer,
it can mean almost anything. */
#define CLASSTYPE_MTABLE_ENTRY(NODE) (TYPE_LANG_SPECIFIC(NODE)->memoized_table_entry)
/* These are the size, mode and alignment of the type without its
virtual base classes, for when we use this type as a base itself. */
#define CLASSTYPE_SIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->size)
@ -935,12 +922,6 @@ struct lang_type
case of a template friend. */
#define CLASSTYPE_FRIEND_CLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->friend_classes)
#ifdef MI_MATRIX
/* Keep an inheritance lattice around so we can quickly tell whether
a type is derived from another or not. */
#define CLASSTYPE_MI_MATRIX(NODE) (TYPE_LANG_SPECIFIC(NODE)->mi_matrix)
#endif
/* Say whether this node was declared as a "class" or a "struct". */
#define CLASSTYPE_DECLARED_CLASS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_class)
@ -976,14 +957,6 @@ struct lang_type
depth-first order via TREE_CHAIN. Other than that, TREE_CHAIN is
unused. */
#ifdef MI_MATRIX
/* When building a matrix to determine by a single lookup
whether one class is derived from another or not,
this field is the index of the class in the table. */
#define CLASSTYPE_CID(NODE) (TYPE_LANG_SPECIFIC(NODE)->cid)
#define BINFO_CID(NODE) CLASSTYPE_CID(BINFO_TYPE(NODE))
#endif
/* Nonzero means marked by DFS or BFS search, including searches
by `get_binfo' and `get_base_distance'. */
#define BINFO_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED(BINFO_TYPE(NODE)):TREE_LANG_FLAG_0(NODE))
@ -2876,8 +2849,6 @@ extern void synthesize_tinfo_fn PROTO((tree));
/* in search.c */
extern int types_overlap_p PROTO((tree, tree));
extern void push_memoized_context PROTO((tree, int));
extern void pop_memoized_context PROTO((int));
extern tree get_vbase PROTO((tree, tree));
extern tree get_binfo PROTO((tree, tree, int));
extern int get_base_distance PROTO((tree, tree, int, tree *));
@ -2895,16 +2866,10 @@ extern tree init_vbase_pointers PROTO((tree, tree));
extern void expand_indirect_vtbls_init PROTO((tree, tree, tree));
extern void clear_search_slots PROTO((tree));
extern tree get_vbase_types PROTO((tree));
extern void build_mi_matrix PROTO((tree));
extern void free_mi_matrix PROTO((void));
extern void build_mi_virtuals PROTO((int, int));
extern void add_mi_virtuals PROTO((int, tree));
extern void report_ambiguous_mi_virtuals PROTO((int, tree));
extern void note_debug_info_needed PROTO((tree));
extern void push_class_decls PROTO((tree));
extern void pop_class_decls PROTO((void));
extern void unuse_fields PROTO((tree));
extern void unmark_finished_struct PROTO((tree));
extern void print_search_statistics PROTO((void));
extern void init_search_processing PROTO((void));
extern void reinit_search_statistics PROTO((void));

4
gcc/cp/decl.c
View File

@ -12478,8 +12478,6 @@ start_function (declspecs, declarator, attrs, pre_parsed_p)
}
else
{
if (!DECL_STATIC_FUNCTION_P (decl1))
push_memoized_context (NULL_TREE, 1);
current_class_ptr = current_class_ref = NULL_TREE;
}
@ -13225,8 +13223,6 @@ finish_function (lineno, call_poplevel, nested)
ctype = current_class_type;
pop_nested_class (1);
}
else
pop_memoized_context (1);
/* Must mark the RESULT_DECL as being in this function. */
DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;

19
gcc/cp/decl2.c
View File

@ -343,10 +343,6 @@ int flag_all_virtual;
int flag_this_is_variable;
/* Nonzero means memoize our member lookups. */
int flag_memoize_lookups; int flag_save_memoized_contexts;
/* 3 means write out only virtuals function tables `defined'
in this implementation file.
2 means write out only specific virtual function tables
@ -491,7 +487,6 @@ static struct { char *string; int *variable; int on_value;} lang_f_options[] =
{"this-is-variable", &flag_this_is_variable, 1},
{"strict-prototype", &flag_strict_prototype, 1},
{"all-virtual", &flag_all_virtual, 1},
{"memoize-lookups", &flag_memoize_lookups, 1},
{"elide-constructors", &flag_elide_constructors, 1},
{"handle-exceptions", &flag_exceptions, 1},
{"handle-signatures", &flag_handle_signatures, 1},
@ -578,16 +573,12 @@ lang_decode_option (argc, argv)
|| !strcmp (p, "no-handle-exceptions"))
warning ("-fhandle-exceptions has been renamed to -fexceptions (and is now on by default)");
if (!strcmp (p, "save-memoized"))
if (!strcmp (p, "memoize-lookups")
|| !strcmp (p, "no-memoize-lookups")
|| !strcmp (p, "save-memoized")
|| !strcmp (p, "no-save-memoized"))
{
flag_memoize_lookups = 1;
flag_save_memoized_contexts = 1;
found = 1;
}
else if (!strcmp (p, "no-save-memoized"))
{
flag_memoize_lookups = 0;
flag_save_memoized_contexts = 0;
/* ignore */
found = 1;
}
else if (! strcmp (p, "alt-external-templates"))

10
gcc/cp/init.c
View File

@ -1614,8 +1614,6 @@ build_offset_ref (type, name)
lookup_fnfield. */
if (fnfields)
{
extern int flag_save_memoized_contexts;
/* Go from the TREE_BASELINK to the member function info. */
t = TREE_VALUE (fnfields);
@ -1670,15 +1668,13 @@ build_offset_ref (type, name)
/* FNFIELDS is most likely allocated on the search_obstack,
which will go away after this class scope. If we need
to save this value for later (either for memoization
or for use as an initializer for a static variable), then
do so here.
to save this value for later (i.e. for use as an initializer
for a static variable), then do so here.
??? The smart thing to do for the case of saving initializers
is to resolve them before we're done with this scope. */
if (!TREE_PERMANENT (fnfields)
&& ((flag_save_memoized_contexts && toplevel_bindings_p ())
|| ! allocation_temporary_p ()))
&& ! allocation_temporary_p ())
fnfields = copy_list (fnfields);
t = build_tree_list (error_mark_node, fnfields);

6
gcc/cp/lang-options.h
View File

@ -56,7 +56,7 @@ DEFINE_LANG_NAME ("C++")
{ "-fno-guiding-decls", "" },
{ "-fgnu-keywords", "" },
{ "-fno-gnu-keywords", "Do not recognise GNU defined keywords" },
{ "-fhandle-exceptions", "Enable exception handling" },
{ "-fhandle-exceptions", "" },
{ "-fno-handle-exceptions", "" },
{ "-fhandle-signatures", "Handle signature language constructs" },
{ "-fno-handle-signatures", "" },
@ -72,7 +72,7 @@ DEFINE_LANG_NAME ("C++")
{ "-fno-init-priority", "" },
{ "-flabels-ok", "Labels can be used as first class objects" },
{ "-fno-labels-ok", "" },
{ "-fmemoize-lookups", "Enable caching of member function resolutions" },
{ "-fmemoize-lookups", "" },
{ "-fno-memoize-lookups", "" },
{ "-fname-mangling-version-", "Set the version of name mangling to use" },
{ "-fnew-abi", "Enable experimental ABI changes" },
@ -85,7 +85,7 @@ DEFINE_LANG_NAME ("C++")
{ "-fno-optional-diags", "Disable optional diagnostics" },
{ "-frepo", "Enable automatic template instantiation" },
{ "-fno-repo", "" },
{ "-fsave-memoized", "Save cache of member function resolutions" },
{ "-fsave-memoized", "" },
{ "-fno-save-memoized", "" },
{ "-fsquangle", "Enable squashed name mangling" },
{ "-fno-squangle", "" },

658
gcc/cp/search.c
View File

@ -76,8 +76,6 @@ pop_stack_level (stack)
#define search_level stack_level
static struct search_level *search_stack;
static void clear_memoized_cache PROTO((void));
static tree make_memoized_table_entry PROTO((tree, tree, int));
static tree get_abstract_virtuals_1 PROTO((tree, int, tree));
static tree get_vbase_1 PROTO((tree, tree, unsigned int *));
static tree convert_pointer_to_vbase PROTO((tree, tree));
@ -104,20 +102,11 @@ static void fixup_virtual_upcast_offsets
tree *));
static int markedp PROTO((tree));
static int unmarkedp PROTO((tree));
#ifdef MI_MATRIX
static int numberedp PROTO((tree));
static int unnumberedp PROTO((tree));
#endif
static int marked_vtable_pathp PROTO((tree));
static int unmarked_vtable_pathp PROTO((tree));
static int marked_new_vtablep PROTO((tree));
static int unmarked_new_vtablep PROTO((tree));
static int dfs_debug_unmarkedp PROTO((tree));
#ifdef MI_MATRIX
static void dfs_number PROTO((tree));
static void dfs_unnumber PROTO((tree));
static void dfs_record_inheritance PROTO((tree));
#endif
static void dfs_debug_mark PROTO((tree));
static void dfs_find_vbases PROTO((tree));
static void dfs_clear_vbase_slots PROTO((tree));
@ -136,14 +125,6 @@ static struct search_level *push_search_level
PROTO((struct stack_level *, struct obstack *));
static struct search_level *pop_search_level
PROTO((struct stack_level *));
static struct type_level *push_type_level
PROTO((struct stack_level *, struct obstack *));
static struct type_level *pop_type_level
PROTO((struct type_level *));
static tree my_tree_cons PROTO((tree, tree, tree));
static tree my_build_string PROTO((char *));
static struct memoized_entry * my_new_memoized_entry
PROTO((struct memoized_entry *));
static HOST_WIDE_INT breadth_first_search
PROTO((tree, int (*) (tree, int), int (*) (tree, int)));
@ -175,39 +156,11 @@ pop_search_level (obstack)
return stack;
}
/* 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;
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];
#ifdef GATHER_STATISTICS
static int n_fields_searched;
static int n_calls_lookup_field, n_calls_lookup_field_1;
@ -217,259 +170,9 @@ static int n_outer_fields_searched;
static int n_contexts_saved;
#endif /* GATHER_STATISTICS */
/* Local variables to help save memoization contexts. */
static tree prev_type_memoized;
static struct type_level *prev_type_stack;
/* This list is used by push_class_decls to know what decls need to
be pushed into class scope. */
static tree closed_envelopes = NULL_TREE;
/* 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;
struct obstack *ambient_obstack = current_obstack;
current_obstack = &type_obstack_entries;
p = tree_cons (purpose, value, chain);
current_obstack = ambient_obstack;
++my_tree_node_counter;
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 ((char *) p, sizeof (struct memoized_entry));
MEMOIZED_CHAIN (p) = chain;
MEMOIZED_UID (p) = ++my_memoized_entry_counter;
return p;
}
/* Clears the deferred pop from pop_memoized_context, if any. */
static void
clear_memoized_cache ()
{
if (prev_type_stack)
{
type_stack = pop_type_level (prev_type_stack);
prev_type_memoized = 0;
prev_type_stack = 0;
}
}
/* Make an entry in the memoized table for type TYPE
that the entry for NAME is FIELD. */
static tree
make_memoized_table_entry (type, name, function_p)
tree type, name;
int function_p;
{
int idx = MEMOIZED_HASH_FN (name);
tree entry, *prev_entry;
/* Since we allocate from the type_obstack, we must pop any deferred
levels. */
clear_memoized_cache ();
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), idx);
else
prev_entry = &MEMOIZED_FIELDS (CLASSTYPE_MTABLE_ENTRY (type), idx);
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 an access control 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 /* GATHER_STATISTICS */
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. */
clear_memoized_cache ();
}
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]);
/* If there was a deferred pop, we need to pop it now. */
clear_memoized_cache ();
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;
}
/* Get a virtual binfo that is found inside BINFO's hierarchy that is
the same type as the type given in PARENT. To be optimal, we want
@ -1193,10 +896,6 @@ lookup_field (xbasetype, name, protect, want_type)
char *errstr = 0;
/* Set this to nonzero if we don't know how to compute
accurate error messages for access control. */
int idx = MEMOIZED_HASH_FN (name);
#if 0
/* We cannot search for constructor/destructor names like this. */
/* This can't go here, but where should it go? */
@ -1232,47 +931,14 @@ lookup_field (xbasetype, name, protect, want_type)
complete_type (type);
if (CLASSTYPE_MTABLE_ENTRY (type))
{
tree tem = MEMOIZED_FIELDS (CLASSTYPE_MTABLE_ENTRY (type), idx);
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 /* GATHER_STATISTICS */
if (protect && flag_memoize_lookups && ! toplevel_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)
{
if (entry)
TREE_VALUE (entry) = rval;
if (rval)
{
if (want_type)
@ -1339,13 +1005,13 @@ lookup_field (xbasetype, name, protect, want_type)
tree btypes;
SET_BINFO_FIELDS_MARKED (base_binfo);
btypes = my_tree_cons (NULL_TREE, base_binfo, basetype_chain);
btypes = scratch_tree_cons (NULL_TREE, base_binfo, basetype_chain);
if (TREE_VIA_VIRTUAL (base_binfo))
btypes = my_tree_cons (NULL_TREE,
btypes = scratch_tree_cons (NULL_TREE,
TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i))),
btypes);
else
btypes = my_tree_cons (NULL_TREE,
btypes = scratch_tree_cons (NULL_TREE,
TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i),
btypes);
obstack_ptr_grow (&search_obstack, btypes);
@ -1398,7 +1064,7 @@ lookup_field (xbasetype, name, protect, want_type)
if (nval)
{
rval = nval;
if (entry || protect)
if (protect)
this_v = compute_access (basetype_path, rval);
/* These may look ambiguous, but they really are not. */
if (vbase_name_p)
@ -1425,9 +1091,6 @@ lookup_field (xbasetype, name, protect, want_type)
tree *tp = search_stack->first;
tree *search_tail = tp + tail;
if (entry)
TREE_VALUE (entry) = rval;
if (rval_binfo)
{
type = BINFO_TYPE (rval_binfo);
@ -1457,7 +1120,7 @@ lookup_field (xbasetype, name, protect, want_type)
/* If this FIELD_DECL defines its own access level, deal with that. */
if (rval && errstr == 0
&& ((protect&1) || entry)
&& (protect & 1)
&& DECL_LANG_SPECIFIC (rval)
&& DECL_ACCESS (rval))
{
@ -1508,21 +1171,6 @@ lookup_field (xbasetype, name, protect, want_type)
}
out:
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 (protect == 2)
{
/* If we are not interested in ambiguities, don't report them,
@ -1707,8 +1355,8 @@ lookup_fnfields (basetype_path, name, complain)
{
int head = 0, tail = 0;
tree type, rval, rval_binfo = NULL_TREE, rvals = NULL_TREE;
tree rval_binfo_h = NULL_TREE, entry, binfo, basetype_chain, binfo_h;
int find_all = 0;
tree rval_binfo_h = NULL_TREE, binfo, basetype_chain, binfo_h;
int idx, 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
@ -1729,10 +1377,6 @@ lookup_fnfields (basetype_path, name, complain)
char *errstr = 0;
/* Set this to nonzero if we don't know how to compute
accurate error messages for access control. */
int idx = MEMOIZED_HASH_FN (name);
if (complain == -1)
{
find_all = 1;
@ -1752,65 +1396,9 @@ lookup_fnfields (basetype_path, name, complain)
binfo_h = binfo;
type = complete_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), idx);
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 access 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 /* GATHER_STATISTICS */
if (protect && flag_memoize_lookups && ! toplevel_bindings_p ())
entry = make_memoized_table_entry (type, name, 1);
else
entry = 0;
idx = lookup_fnfields_here (type, name);
if (idx >= 0 || lookup_field_1 (type, name))
@ -1822,16 +1410,10 @@ lookup_fnfields (basetype_path, name, complain)
if (idx >= 0)
{
rval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), idx);
rvals = my_tree_cons (basetype_path, rval, rvals);
rvals = scratch_tree_cons (basetype_path, rval, rvals);
if (BINFO_BASETYPES (binfo) && CLASSTYPE_BASELINK_VEC (type))
TREE_TYPE (rvals) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), idx);
if (entry)
{
TREE_VALUE (entry) = rvals;
TREE_TYPE (entry) = NULL_TREE;
}
return rvals;
}
rval = NULL_TREE;
@ -1840,9 +1422,6 @@ lookup_fnfields (basetype_path, name, complain)
{
/* Don't allow lookups of constructors and destructors to go
deeper than the first place we look. */
if (entry)
TREE_TYPE (entry) = TREE_VALUE (entry) = NULL_TREE;
return NULL_TREE;
}
@ -1876,13 +1455,13 @@ lookup_fnfields (basetype_path, name, complain)
tree btypes;
SET_BINFO_FIELDS_MARKED (base_binfo);
btypes = my_tree_cons (NULL_TREE, base_binfo, basetype_chain);
btypes = scratch_tree_cons (NULL_TREE, base_binfo, basetype_chain);
if (TREE_VIA_VIRTUAL (base_binfo))
btypes = my_tree_cons (NULL_TREE,
btypes = scratch_tree_cons (NULL_TREE,
TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i))),
btypes);
else
btypes = my_tree_cons (NULL_TREE,
btypes = scratch_tree_cons (NULL_TREE,
TREE_VEC_ELT (BINFO_BASETYPES (binfo_h), i),
btypes);
obstack_ptr_grow (&search_obstack, btypes);
@ -1933,7 +1512,7 @@ lookup_fnfields (basetype_path, name, complain)
rval = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), idx);
/* Note, rvals can only be previously set if find_all is
true. */
rvals = my_tree_cons (basetype_path, rval, rvals);
rvals = scratch_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), idx);
@ -1968,22 +1547,6 @@ lookup_fnfields (basetype_path, name, complain)
}
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)
{
cp_error (errstr, name);
@ -2492,33 +2055,6 @@ next_baselink (baselink)
/* DEPTH-FIRST SEARCH ROUTINES. */
#ifdef MI_MATRIX
/* 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))
#endif
/* 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
@ -2611,14 +2147,6 @@ dfs_walk (binfo, fn, qfn)
fn (binfo);
}
#ifdef MI_MATRIX
/* 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; }
#endif
static int markedp (binfo) tree binfo;
{ return BINFO_MARKED (binfo); }
static int unmarkedp (binfo) tree binfo;
@ -2664,25 +2192,6 @@ static int dfs_debug_unmarkedp (binfo) tree binfo;
test anything (vis a vis marking) if they are paired with
a predicate function (above). */
#ifdef MI_MATRIX
/* 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;
}
#endif
#if 0
static void
dfs_mark (binfo) tree binfo;
@ -3229,95 +2738,6 @@ get_vbase_types (type)
return vbase_types;
}
#ifdef MI_MATRIX
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);
if (TREE_CODE (baseclass) == TEMPLATE_TYPE_PARM
|| TREE_CODE (baseclass) == TEMPLATE_TEMPLATE_PARM)
continue;
my_friendly_assert (CLASSTYPE_CID (baseclass) != 0, 2365);
/* 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
dfs_walk (binfo, dfs_number, unnumberedp);
mi_size = CLASSTYPE_N_SUPERCLASSES (type) + CLASSTYPE_N_VBASECLASSES (type);
if (mi_size < (cid-1))
mi_size = cid-1;
mi_matrix = (char *)xmalloc ((mi_size + 1) * (mi_size + 1));
mi_type = type;
bzero (mi_matrix, (mi_size + 1) * (mi_size + 1));
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
}
#endif
/* 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
@ -3404,16 +2824,7 @@ envelope_add_decl (type, decl, values)
dont_add = 1;
}
else if (type == current_class_type
#ifdef MI_MATRIX
/* If we don't check CLASSTYPE_CID on CONTEXT right now,
we'll end up subtracting from the address of MI_MATRIX,
putting us off in la la land. */
|| (CLASSTYPE_CID (type)
&& TYPE_DERIVES_FROM (context, type))
#else
|| DERIVED_FROM_P (context, type)
#endif
)
|| DERIVED_FROM_P (context, type))
{
/* Don't add in *values to list */
*values = NULL_TREE;
@ -3432,16 +2843,7 @@ envelope_add_decl (type, decl, values)
: DECL_CONTEXT (value);
if (type == current_class_type
#ifdef MI_MATRIX
/* If we don't check CLASSTYPE_CID on CONTEXT right now,
we'll end up subtracting from the address of MI_MATRIX,
putting us off in la la land. */
|| (CLASSTYPE_CID (type)
&& TYPE_DERIVES_FROM (context, type))
#else
|| DERIVED_FROM_P (context, type)
#endif
)
|| DERIVED_FROM_P (context, type))
{
/* remove *tmp from list */
*tmp = TREE_CHAIN (*tmp);
@ -3781,23 +3183,6 @@ 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",
@ -3812,27 +3197,12 @@ void
init_search_processing ()
{
gcc_obstack_init (&search_obstack);
gcc_obstack_init (&type_obstack);
gcc_obstack_init (&type_obstack_entries);
/* This gives us room to build our chains of basetypes,
whether or not we decide to memoize them. */
type_stack = push_type_level ((struct stack_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;
#ifdef GATHER_STATISTICS
n_fields_searched = 0;
n_calls_lookup_field = 0, n_calls_lookup_field_1 = 0;