From 6d160691ef8dd49892d3830df40e13dc84d4661c Mon Sep 17 00:00:00 2001 From: Mark Mitchell Date: Thu, 8 Jul 2004 04:32:27 +0000 Subject: * cp-tree.h (saved_scope): Remove x_previous_class_type and x_previous_class_values; add x_previous_class_level. (previous_class_type): Remove. (previous_class_values): Remove. (previous_class_level): New macro. * class.c (pushclass): Restore the identifier cache more expeditiously. (invalidate_class_lookup_cache): Use vector for class_shadowed and previous_class_values. * decl.c (poplevel): Likewise. * name-lookup.c (cxx_binding_init): New function. (cxx_binding_make): Use it. (push_binding): For a binding in a class level, use a vector of cp_class_binding nodes. (push_binding_level): New function. (begin_scope): Use it. (leave_scope): Do not put class binding levels on the free list. (print_binding_level): Adjust for the fact that class_shadowed is a vector. (poplevel_class): Likewise. (clear_identifier_class_values): Likewise. (push_class_level_binding): Likewise. (set_class_shadows): Remove. (store_binding): New function. (store_class_bindings): New function. (push_to_top_level): Use store_class_bindings as appropriate. (pop_from_top_level): Use previous_class_level, not previous_class_type. * name-lookup.h (cp_class_binding): New type. (cp_binding_level): Use a vector object for class_shadowed. (push_binding_level): Declare. (set_class_shadows): Remove. git-svn-id: https://gcc.gnu.org/svn/gcc/trunk@84259 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/cp/ChangeLog | 35 +++++++ gcc/cp/class.c | 54 ++++++---- gcc/cp/cp-tree.h | 15 +-- gcc/cp/decl.c | 3 +- gcc/cp/name-lookup.c | 277 ++++++++++++++++++++++++++++++++------------------- gcc/cp/name-lookup.h | 13 ++- 6 files changed, 259 insertions(+), 138 deletions(-) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 839745b3a84..5d2aae04082 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,38 @@ +2004-07-07 Mark Mitchell + + * cp-tree.h (saved_scope): Remove x_previous_class_type and + x_previous_class_values; add x_previous_class_level. + (previous_class_type): Remove. + (previous_class_values): Remove. + (previous_class_level): New macro. + * class.c (pushclass): Restore the identifier cache more + expeditiously. + (invalidate_class_lookup_cache): Use vector for class_shadowed and + previous_class_values. + * decl.c (poplevel): Likewise. + * name-lookup.c (cxx_binding_init): New function. + (cxx_binding_make): Use it. + (push_binding): For a binding in a class level, use a vector of + cp_class_binding nodes. + (push_binding_level): New function. + (begin_scope): Use it. + (leave_scope): Do not put class binding levels on the free list. + (print_binding_level): Adjust for the fact that class_shadowed is + a vector. + (poplevel_class): Likewise. + (clear_identifier_class_values): Likewise. + (push_class_level_binding): Likewise. + (set_class_shadows): Remove. + (store_binding): New function. + (store_class_bindings): New function. + (push_to_top_level): Use store_class_bindings as appropriate. + (pop_from_top_level): Use previous_class_level, not + previous_class_type. + * name-lookup.h (cp_class_binding): New type. + (cp_binding_level): Use a vector object for class_shadowed. + (push_binding_level): Declare. + (set_class_shadows): Remove. + 2004-07-07 Andrew Pinski * class.c (instantiate_type): BUFFER_REF is dead. diff --git a/gcc/cp/class.c b/gcc/cp/class.c index e4117278690..1f3b22a7ddc 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -5486,9 +5486,8 @@ pushclass (tree type) ? access_private_node : access_public_node); - if (previous_class_type != NULL_TREE - && (type != previous_class_type - || !COMPLETE_TYPE_P (previous_class_type)) + if (previous_class_level + && type != previous_class_level->this_entity && current_class_depth == 1) { /* Forcibly remove any old class remnants. */ @@ -5500,10 +5499,11 @@ pushclass (tree type) if (current_class_depth > 1) clear_identifier_class_values (); - pushlevel_class (); - - if (type != previous_class_type || current_class_depth > 1) + if (!previous_class_level + || type != previous_class_level->this_entity + || current_class_depth > 1) { + pushlevel_class (); push_class_decls (type); if (CLASSTYPE_TEMPLATE_INFO (type) && !CLASSTYPE_USE_TEMPLATE (type)) { @@ -5520,22 +5520,33 @@ pushclass (tree type) } else { - tree item; + cp_class_binding *cb; + size_t i; /* We are re-entering the same class we just left, so we don't have to search the whole inheritance matrix to find all the decls to bind again. Instead, we install the cached class_shadowed list, and walk through it binding names and setting up IDENTIFIER_TYPE_VALUEs. */ - set_class_shadows (previous_class_values); - for (item = previous_class_values; item; item = TREE_CHAIN (item)) + push_binding_level (previous_class_level); + class_binding_level = previous_class_level; + for (i = 0; + (cb = VEC_iterate (cp_class_binding, + previous_class_level->class_shadowed, + i)); + ++i) { - tree id = TREE_PURPOSE (item); - tree decl = TREE_TYPE (item); - - push_class_binding (id, decl); - if (TREE_CODE (decl) == TYPE_DECL) - set_identifier_type_value (id, decl); + tree id; + tree type_decl; + + id = cb->identifier; + cb->base.previous = IDENTIFIER_BINDING (id); + IDENTIFIER_BINDING (id) = &cb->base; + type_decl = cb->base.value; + if (!type_decl || TREE_CODE (type_decl) != TYPE_DECL) + type_decl = cb->base.type; + if (type_decl && TREE_CODE (type_decl) == TYPE_DECL) + set_identifier_type_value (id, type_decl); } unuse_fields (type); } @@ -5551,14 +5562,17 @@ pushclass (tree type) void invalidate_class_lookup_cache (void) { - tree t; + size_t i; + cp_class_binding *cb; /* The IDENTIFIER_CLASS_VALUEs are no longer valid. */ - for (t = previous_class_values; t; t = TREE_CHAIN (t)) - IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE; + for (i = 0; + (cb = VEC_iterate (cp_class_binding, + previous_class_level->class_shadowed, i)); + ++i) + IDENTIFIER_CLASS_VALUE (cb->identifier) = NULL_TREE; - previous_class_values = NULL_TREE; - previous_class_type = NULL_TREE; + previous_class_level = NULL; } /* Get out of the current class scope. If we were in a class scope diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 87e610eaa19..15cfd8457f8 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -640,8 +640,7 @@ struct saved_scope GTY(()) varray_type lang_base; tree lang_name; tree template_parms; - tree x_previous_class_type; - tree x_previous_class_values; + struct cp_binding_level *x_previous_class_level; tree x_saved_tree; HOST_WIDE_INT x_processing_template_decl; @@ -694,16 +693,10 @@ struct saved_scope GTY(()) #define processing_specialization scope_chain->x_processing_specialization #define processing_explicit_instantiation scope_chain->x_processing_explicit_instantiation -/* _TYPE: the previous type that was a class */ +/* The cached class binding level, from the most recently exited + class, or NULL if none. */ -#define previous_class_type scope_chain->x_previous_class_type - -/* This is a copy of the class_shadowed list of the previous class - binding contour when at global scope. It's used to reset - IDENTIFIER_CLASS_VALUEs when entering another class scope (i.e. a - cache miss). */ - -#define previous_class_values scope_chain->x_previous_class_values +#define previous_class_level scope_chain->x_previous_class_level /* A list of private types mentioned, for deferred access checking. */ diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index d8feecdbc13..f17f91cc4b5 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -443,7 +443,8 @@ poplevel (int keep, int reverse, int functionbody) ? ((functionbody = 0), tmp) : functionbody); subblocks = functionbody >= 0 ? current_binding_level->blocks : 0; - my_friendly_assert (!current_binding_level->class_shadowed, + my_friendly_assert (VEC_length(cp_class_binding, + current_binding_level->class_shadowed) == 0, 19990414); /* We used to use KEEP == 2 to indicate that the new block should go diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c index 7c44c8970d8..879d2bf6897 100644 --- a/gcc/cp/name-lookup.c +++ b/gcc/cp/name-lookup.c @@ -328,6 +328,17 @@ binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data) static GTY((deletable)) cxx_binding *free_bindings; +/* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS + field to NULL. */ + +static inline void +cxx_binding_init (cxx_binding *binding, tree value, tree type) +{ + binding->value = value; + binding->type = type; + binding->previous = NULL; +} + /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */ static cxx_binding * @@ -342,9 +353,7 @@ cxx_binding_make (tree value, tree type) else binding = ggc_alloc (sizeof (cxx_binding)); - binding->value = value; - binding->type = type; - binding->previous = NULL; + cxx_binding_init (binding, value, type); return binding; } @@ -365,8 +374,31 @@ cxx_binding_free (cxx_binding *binding) static void push_binding (tree id, tree decl, cxx_scope* level) { - cxx_binding *binding = cxx_binding_make (decl, NULL); + cxx_binding *binding; + if (level != class_binding_level) + binding = cxx_binding_make (decl, NULL_TREE); + else + { + cp_class_binding *cb; + size_t length; + size_t i; + bool need_fixup; + + length = VEC_length (cp_class_binding, level->class_shadowed); + need_fixup = (length && length == level->class_shadowed->alloc); + cb = VEC_safe_push (cp_class_binding, level->class_shadowed, NULL); + cb->identifier = id; + binding = &cb->base; + cxx_binding_init (binding, decl, NULL_TREE); + if (need_fixup) + for (i = 0; i < length; ++i) + { + cb = VEC_index (cp_class_binding, level->class_shadowed, i); + IDENTIFIER_BINDING (cb->identifier) = &cb->base; + } + } + /* Now, fill in the binding information. */ binding->previous = IDENTIFIER_BINDING (id); binding->scope = level; @@ -1261,6 +1293,26 @@ namespace_scope_ht_size (tree ns) static GTY((deletable)) struct cp_binding_level *free_binding_level; +/* Insert SCOPE as the innermost binding level. */ + +void +push_binding_level (struct cp_binding_level *scope) +{ + /* Add it to the front of currently active scopes stack. */ + scope->level_chain = current_binding_level; + current_binding_level = scope; + keep_next_level_flag = false; + + if (ENABLE_SCOPE_CHECKING) + { + scope->binding_depth = binding_depth; + indent (binding_depth); + cxx_scope_debug (scope, input_line, "push"); + is_class_level = 0; + binding_depth++; + } +} + /* Create a new KIND scope and make it the top of the active scopes stack. ENTITY is the scope of the associated C++ entity (namespace, class, function); it is NULL otherwise. */ @@ -1319,19 +1371,7 @@ begin_scope (scope_kind kind, tree entity) } scope->kind = kind; - /* Add it to the front of currently active scopes stack. */ - scope->level_chain = current_binding_level; - current_binding_level = scope; - keep_next_level_flag = false; - - if (ENABLE_SCOPE_CHECKING) - { - scope->binding_depth = binding_depth; - indent (binding_depth); - cxx_scope_debug (scope, input_line, "push"); - is_class_level = 0; - binding_depth++; - } + push_binding_level (scope); return scope; } @@ -1366,11 +1406,13 @@ leave_scope (void) /* Move one nesting level up. */ current_binding_level = scope->level_chain; - /* Namespace-scopes are left most probably temporarily, not completely; - they can be reopen later, e.g. in namespace-extension or any name - binding activity that requires us to resume a namespace. For other + /* Namespace-scopes are left most probably temporarily, not + completely; they can be reopen later, e.g. in namespace-extension + or any name binding activity that requires us to resume a + namespace. For classes, we cache some binding levels. For other scopes, we just make the structure available for reuse. */ - if (scope->kind != sk_namespace) + if (scope->kind != sk_namespace + && scope->kind != sk_class) { scope->level_chain = free_binding_level; if (scope->kind == sk_class) @@ -1628,13 +1670,17 @@ print_binding_level (struct cp_binding_level* lvl) if (i) fprintf (stderr, "\n"); } - if (lvl->class_shadowed) + if (VEC_length (cp_class_binding, lvl->class_shadowed)) { + size_t i; + cp_class_binding *b; fprintf (stderr, " class-shadowed:"); - for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t)) - { - fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t))); - } + for (i = 0; + (b = VEC_iterate(cp_class_binding, + lvl->class_shadowed, + i)); + ++i) + fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier)); fprintf (stderr, "\n"); } if (lvl->type_shadowed) @@ -2576,6 +2622,8 @@ void poplevel_class (void) { struct cp_binding_level *level = class_binding_level; + cp_class_binding *cb; + size_t i; tree shadowed; timevar_push (TV_NAME_LOOKUP); @@ -2589,12 +2637,11 @@ poplevel_class (void) if (current_class_depth != 1) { struct cp_binding_level* b; + cp_class_binding* cb; + size_t i; /* Clear out our IDENTIFIER_CLASS_VALUEs. */ - for (shadowed = level->class_shadowed; - shadowed; - shadowed = TREE_CHAIN (shadowed)) - IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE; + clear_identifier_class_values (); /* Find the next enclosing class, and recreate IDENTIFIER_CLASS_VALUEs appropriate for that class. */ @@ -2603,38 +2650,36 @@ poplevel_class (void) b = b->level_chain; if (b) - for (shadowed = b->class_shadowed; - shadowed; - shadowed = TREE_CHAIN (shadowed)) + for (i = 0; + (cb = VEC_iterate (cp_class_binding, + b->class_shadowed, + i)); + ++i) { cxx_binding *binding; - binding = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed)); + binding = IDENTIFIER_BINDING (cb->identifier); while (binding && binding->scope != b) binding = binding->previous; if (binding) - IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) - = binding->value; + IDENTIFIER_CLASS_VALUE (cb->identifier) = binding->value; } } else /* Remember to save what IDENTIFIER's were bound in this scope so we can recover from cache misses. */ - { - previous_class_type = current_class_type; - previous_class_values = class_binding_level->class_shadowed; - } + previous_class_level = level; for (shadowed = level->type_shadowed; shadowed; shadowed = TREE_CHAIN (shadowed)) SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed)); /* Remove the bindings for all of the class-level declarations. */ - for (shadowed = level->class_shadowed; - shadowed; - shadowed = TREE_CHAIN (shadowed)) - pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed)); + for (i = 0; + (cb = VEC_iterate (cp_class_binding, level->class_shadowed, i)); + ++i) + IDENTIFIER_BINDING (cb->identifier) = cb->base.previous; /* Now, pop out of the binding level which we created up in the `pushlevel_class' routine. */ @@ -2707,15 +2752,16 @@ push_class_binding (tree id, tree decl) void clear_identifier_class_values (void) { - tree t; - - if (!class_binding_level) - return; + size_t i; + cp_class_binding *cb; - for (t = class_binding_level->class_shadowed; - t; - t = TREE_CHAIN (t)) - IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE; + if (class_binding_level) + for (i = 0; + (cb = VEC_iterate (cp_class_binding, + class_binding_level->class_shadowed, + i)); + ++i) + IDENTIFIER_CLASS_VALUE (cb->identifier) = NULL_TREE; } /* Make the declaration of X appear in CLASS scope. */ @@ -2859,22 +2905,25 @@ push_class_level_binding (tree name, tree x) old_decl = bval; else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x)) POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true); - + if (old_decl) { - tree shadow; - + cp_class_binding *cb; + size_t i; + /* Find the previous binding of name on the class-shadowed list, and update it. */ - for (shadow = class_binding_level->class_shadowed; - shadow; - shadow = TREE_CHAIN (shadow)) - if (TREE_PURPOSE (shadow) == name - && TREE_TYPE (shadow) == old_decl) + for (i = 0; + (cb = VEC_iterate (cp_class_binding, + class_binding_level->class_shadowed, + i)); + ++i) + if (cb->identifier == name + && (cb->base.value == old_decl + || cb->base.type == old_decl)) { binding->value = x; INHERITED_VALUE_BINDING_P (binding) = 0; - TREE_TYPE (shadow) = x; IDENTIFIER_CLASS_VALUE (name) = x; POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true); } @@ -2884,15 +2933,7 @@ push_class_level_binding (tree name, tree x) /* If we didn't replace an existing binding, put the binding on the stack of bindings for the identifier, and update the shadowed list. */ if (push_class_binding (name, x)) - { - class_binding_level->class_shadowed - = tree_cons (name, NULL, - class_binding_level->class_shadowed); - /* Record the value we are binding NAME to so that we can know - what to pop later. */ - TREE_TYPE (class_binding_level->class_shadowed) = x; - POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true); - } + POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true); POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false); } @@ -2945,11 +2986,6 @@ do_class_using_decl (tree decl) return value; } -void -set_class_shadows (tree shadows) -{ - class_binding_level->class_shadowed = shadows; -} /* Return the binding value for name in scope. */ @@ -4796,6 +4832,41 @@ struct cxx_saved_binding GTY(()) scope isn't enough, because more binding levels may be pushed. */ struct saved_scope *scope_chain; +/* If ID is not already in the SEARCH_BINDINGS, prepend its binding + information to OLD_BINDINGS. Returns the new OLD_BINDINGS + list. */ + +static cxx_saved_binding * +store_binding (tree id, + cxx_saved_binding *old_bindings, + cxx_saved_binding *search_bindings) +{ + cxx_saved_binding *saved; + cxx_saved_binding *t1; + + if (!id + /* Note that we may have an IDENTIFIER_CLASS_VALUE even when + we have no IDENTIFIER_BINDING if we have left the class + scope, but cached the class-level declarations. */ + || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id))) + return old_bindings; + + for (t1 = search_bindings; t1; t1 = t1->previous) + if (t1->identifier == id) + return old_bindings; + + my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135); + saved = cxx_saved_binding_make (); + saved->previous = old_bindings; + saved->identifier = id; + saved->binding = IDENTIFIER_BINDING (id); + saved->class_value = IDENTIFIER_CLASS_VALUE (id);; + saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id); + IDENTIFIER_BINDING (id) = NULL; + IDENTIFIER_CLASS_VALUE (id) = NULL_TREE; + return saved; +} + static cxx_saved_binding * store_bindings (tree names, cxx_saved_binding *old_bindings) { @@ -4806,41 +4877,38 @@ store_bindings (tree names, cxx_saved_binding *old_bindings) for (t = names; t; t = TREE_CHAIN (t)) { tree id; - cxx_saved_binding *saved; - cxx_saved_binding *t1; if (TREE_CODE (t) == TREE_LIST) id = TREE_PURPOSE (t); else id = DECL_NAME (t); - if (!id - /* Note that we may have an IDENTIFIER_CLASS_VALUE even when - we have no IDENTIFIER_BINDING if we have left the class - scope, but cached the class-level declarations. */ - || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id))) - continue; - - for (t1 = search_bindings; t1; t1 = t1->previous) - if (t1->identifier == id) - goto skip_it; - - my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135); - saved = cxx_saved_binding_make (); - saved->previous = old_bindings; - saved->identifier = id; - saved->binding = IDENTIFIER_BINDING (id); - saved->class_value = IDENTIFIER_CLASS_VALUE (id);; - saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id); - IDENTIFIER_BINDING (id) = NULL; - IDENTIFIER_CLASS_VALUE (id) = NULL_TREE; - old_bindings = saved; - skip_it: - ; + old_bindings + = store_binding (id, old_bindings, search_bindings); } POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old_bindings); } +/* Like store_bindings, but NAMES is a vector of cp_class_binding + objects, rather than a TREE_LIST. */ + +static cxx_saved_binding * +store_class_bindings (VEC(cp_class_binding) *names, + cxx_saved_binding *old_bindings) +{ + size_t i; + cp_class_binding *cb; + cxx_saved_binding *search_bindings = old_bindings; + + timevar_push (TV_NAME_LOOKUP); + for (i = 0; + (cb = VEC_iterate(cp_class_binding, names, i)); + ++i) + old_bindings + = store_binding (cb->identifier, old_bindings, search_bindings); + POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old_bindings); +} + void push_to_top_level (void) { @@ -4864,8 +4932,9 @@ push_to_top_level (void) need_pop = 0; old_bindings = NULL; - if (scope_chain && previous_class_type) - old_bindings = store_bindings (previous_class_values, old_bindings); + if (scope_chain && previous_class_level) + old_bindings = store_class_bindings (previous_class_level->class_shadowed, + old_bindings); /* Have to include the global scope, because class-scope decls aren't listed anywhere useful. */ @@ -4884,7 +4953,7 @@ push_to_top_level (void) /* We also need to check class_shadowed to save class-level type bindings, since pushclass doesn't fill in b->names. */ if (b->kind == sk_class) - old_bindings = store_bindings (b->class_shadowed, old_bindings); + old_bindings = store_class_bindings (b->class_shadowed, old_bindings); /* Unwind type-value slots back to top level. */ for (t = b->type_shadowed; t; t = TREE_CHAIN (t)) @@ -4912,7 +4981,7 @@ pop_from_top_level (void) timevar_push (TV_NAME_LOOKUP); /* Clear out class-level bindings cache. */ - if (previous_class_type) + if (previous_class_level) invalidate_class_lookup_cache (); current_lang_base = 0; diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h index 49046e893fe..1d1f09f789d 100644 --- a/gcc/cp/name-lookup.h +++ b/gcc/cp/name-lookup.h @@ -117,6 +117,15 @@ typedef enum scope_kind { "template <>", this scope is always empty. */ } scope_kind; +typedef struct cp_class_binding GTY(()) +{ + cxx_binding base; + /* The bound name. */ + tree identifier; +} cp_class_binding; + +DEF_VEC_O(cp_class_binding); + /* For each binding contour we allocate a binding_level structure which records the names defined in that contour. Contours include: @@ -175,7 +184,7 @@ struct cp_binding_level GTY(()) class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node is the name of an entity bound in the class. The TREE_TYPE is the DECL bound by this name in the class. */ - tree class_shadowed; + VEC(cp_class_binding) *class_shadowed; /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and is used for all binding levels. In addition the TREE_VALUE is the @@ -273,6 +282,7 @@ extern void keep_next_level (bool); extern bool is_ancestor (tree, tree); extern bool push_scope (tree); extern void pop_scope (tree); +extern void push_binding_level (struct cp_binding_level *); extern void push_namespace (tree); extern void pop_namespace (void); @@ -299,7 +309,6 @@ extern bool push_class_level_binding (tree, tree); extern void storetags (tree); extern tree getdecls (void); extern tree cp_namespace_decls (tree); -extern void set_class_shadows (tree); extern void set_decl_namespace (tree, tree, bool); extern tree current_decl_namespace (void); extern void push_decl_namespace (tree); -- cgit v1.2.3