diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index a5b99482fd3..c23c4c85916 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,5 +1,15 @@ 1998-08-27 Jason Merrill + * 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. diff --git a/gcc/cp/class.c b/gcc/cp/class.c index a836a095ee1..c8273e5757f 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -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: ; } diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 1ac399a977e..ac7fead7831 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -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)); diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index e3b67acc383..2deeaa80b7c 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -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; diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 098c8435c9d..6a1540bb911 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -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")) diff --git a/gcc/cp/init.c b/gcc/cp/init.c index 29408630e1c..e96f7e50b12 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -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); diff --git a/gcc/cp/lang-options.h b/gcc/cp/lang-options.h index 3c2aee93114..d8f85bd1f20 100644 --- a/gcc/cp/lang-options.h +++ b/gcc/cp/lang-options.h @@ -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", "" }, diff --git a/gcc/cp/search.c b/gcc/cp/search.c index 33fd19bf612..ed378c0e9cd 100644 --- a/gcc/cp/search.c +++ b/gcc/cp/search.c @@ -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;