From patchwork Wed Oct 25 21:36:42 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nathan Sidwell X-Patchwork-Id: 830379 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-465130-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="UmBuXHJC"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3yMk4W6GX8z9s9Y for ; Thu, 26 Oct 2017 08:37:15 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:to :from:subject:message-id:date:mime-version:content-type; q=dns; s=default; b=kdlj0embhGU4JrphBu06UET9tHD3QCeQIxaWt2Z+kOo5a6c9XM Kat7ugLlhbxjXfy3FHmEGtOgTF5dnIEjlwvgYLX0v2SvTOmfwreu4jDvIdL63BZO tPzislati42Kvo3KJ0AOm5OXHZNBcMEDENqZqPKp/b5MBO/BSKACqjRWw= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:to :from:subject:message-id:date:mime-version:content-type; s= default; bh=M7/FnJ0IFoNFq6EJfN0cPJeJTl0=; b=UmBuXHJCq2LOkbEMcJe9 nmPvQ75d+3ziLW72otjju+NoTVcnibvwKc/ayC7DwjPblv/mocmIdsCJT84DjqYh 05qOf/s+xCoDCjiqGzUWSwSsavYu1wczXvd5/o5EByQgIRQTWXHKE9tpZL/EA/ZU YoZ7pmSSakmhbQyPq7z4cP8= Received: (qmail 17308 invoked by alias); 25 Oct 2017 21:36:50 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 17270 invoked by uid 89); 25 Oct 2017 21:36:50 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-10.6 required=5.0 tests=BAYES_00, FREEMAIL_FROM, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, RCVD_IN_DNSWL_NONE, RCVD_IN_SORBS_SPAM, SPF_PASS autolearn=ham version=3.3.2 spammy=lev, flavor, Hang, Pop X-HELO: mail-yw0-f174.google.com Received: from mail-yw0-f174.google.com (HELO mail-yw0-f174.google.com) (209.85.161.174) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 25 Oct 2017 21:36:46 +0000 Received: by mail-yw0-f174.google.com with SMTP id t71so1280539ywc.3 for ; Wed, 25 Oct 2017 14:36:46 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:to:from:subject:message-id:date :user-agent:mime-version:content-language; bh=eVEKyOBfyRiGAqvYrcoVX2vNjf507GFajb4J5j5Cd/w=; b=E+QbNm2SD0TeptgLQterT/lR6oJZ+tQcIw7aooczkRa/RchlVZWHia4YLSmdbFlYGS alrIBkd65uhAjcbOsLPg70pgdMnu8m3kgCJVgcoEb4rvmme5EUL2zdmTlQVlu0bJPnm4 HQ98VtnaqXBw/YrmFen9JdyAqgLJEP0HGn2yqyNLvi+4yOCW9FzRdRF/ssYW5nfrkhZ4 cr08l+1bOrd5VnvYPeBAH7TEP9vN/0WHlGFrkM2jWh4+nlPfIEKCfqnFA8CDbrFL7hl7 HOQ5syWRXXguJoCqw/gXBbnT3xzuP7NlIbpV2AurI0inMBGeVuop6gGLedC7OPqF/VjL GJvA== X-Gm-Message-State: AMCzsaUn8OuwjfEPX6TpAEBgeMEoXVHbfoir4kyjxoWzA5zNczCP+IJj YNSwFPqe/M8NzyIEks7ZfC4= X-Google-Smtp-Source: ABhQp+RB8tPGto9jootOxOrevdGSh8uUq2zmpBm4xNZYpLetUo38y5dtMCWjGsi39uhUkiYnUB0NKg== X-Received: by 10.129.141.20 with SMTP id d20mr3715270ywg.105.1508967404754; Wed, 25 Oct 2017 14:36:44 -0700 (PDT) Received: from ?IPv6:2620:10d:c0a1:1102:495f:7267:5ff:a250? ([2620:10d:c091:180::1:8548]) by smtp.googlemail.com with ESMTPSA id b11sm1729254ywc.84.2017.10.25.14.36.43 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 25 Oct 2017 14:36:44 -0700 (PDT) To: GCC Patches From: Nathan Sidwell Subject: [C++ PATCH] Kill IDENTIFIER_LABEL_VALUE Message-ID: <8d7a547f-3d8e-7a99-5298-e8625863602e@acm.org> Date: Wed, 25 Oct 2017 17:36:42 -0400 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.3.0 MIME-Version: 1.0 This patch removes 'label_value' from lang_identifier, shrinking it from 72 to 64 bytes (on 64-bit machine). We replace this by augmenting the already used per-function named_labels hash table. This is a major win, because labels are extremely rare and there are many identifiers. We also shring the binding structure by a pointer, as the shadowed_labels list goes away. The slight difficulty is with the declared label extension. These have a regular scope and can hide an outer binding. We stash the outer binding in the named_label_entry and restore it when popping that scope. Applying to trunk nathan 2017-10-25 Nathan Sidwell Kill IDENTIFIER_LABEL_VALUE. * cp-tree.h (lang_identifier): Delete label_value slot. (IDENTIFIER_LABEL_VALUE, SET_IDENTIFIER_LABEL_VALUE): Delete. (struct named_label_hasher): Rename to ... (struct named_label_hash): ... here. Reimplement. (struct language_function): Adjust x_named_labels. * name-lookup.h (struct cp_label_binding): Delete. (struct cp_binding_level): Delete shadowed_labels slot. * decl.c (struct named_label_entry): Add name and outer slots. (pop_label): Rename to ... (check_label_used): ... here. Don't pop. (note_label, sort_labels): Delete. (pop_labels, pop_local_label): Reimplement. (poplevel): Pop local labels as any other decl. Remove shadowed_labels handling. (named_label_hash::hash, named_label_hash::equal): New. (make_label_decl): Absorb into ... (lookup_label_1): ... here. Add making_local_p arg, reimplement. (lookup_label, declare_local_label): Adjust. (check_goto, define_label): Adjust. * lex.c (make_conv_op_name): Don't clear IDENTIFIER_LABEL_VALUE. * ptree.c (cxx_print_identifier): Don't print identifier binding. Index: cp-tree.h =================================================================== --- cp-tree.h (revision 254086) +++ cp-tree.h (working copy) @@ -561,7 +561,6 @@ extern GTY(()) tree cp_global_trees[CPTI struct GTY(()) lang_identifier { struct c_common_identifier c_common; cxx_binding *bindings; - tree label_value; }; /* Return a typed pointer version of T if it designates a @@ -996,11 +995,6 @@ enum GTY(()) abstract_class_use { #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE)) #define IDENTIFIER_HAS_TYPE_VALUE(NODE) (IDENTIFIER_TYPE_VALUE (NODE) ? 1 : 0) -#define IDENTIFIER_LABEL_VALUE(NODE) \ - (LANG_IDENTIFIER_CAST (NODE)->label_value) -#define SET_IDENTIFIER_LABEL_VALUE(NODE, VALUE) \ - IDENTIFIER_LABEL_VALUE (NODE) = (VALUE) - /* Kinds of identifiers. Values are carefully chosen. */ enum cp_identifier_kind { cik_normal = 0, /* Not a special identifier. */ @@ -1662,12 +1656,22 @@ struct cxx_int_tree_map_hasher : ggc_ptr static bool equal (cxx_int_tree_map *, cxx_int_tree_map *); }; -struct named_label_entry; +struct named_label_entry; /* Defined in decl.c. */ -struct named_label_hasher : ggc_ptr_hash +struct named_label_hash : ggc_remove { - static hashval_t hash (named_label_entry *); - static bool equal (named_label_entry *, named_label_entry *); + typedef named_label_entry *value_type; + typedef tree compare_type; /* An identifier. */ + + inline static hashval_t hash (value_type); + inline static bool equal (const value_type, compare_type); + + inline static void mark_empty (value_type &p) {p = NULL;} + inline static bool is_empty (value_type p) {return !p;} + + /* Nothing is deletable. Everything is insertable. */ + inline static bool is_deleted (value_type) { return false; } + inline static void mark_deleted (value_type) { gcc_unreachable (); } }; /* Global state pertinent to the current function. */ @@ -1696,7 +1700,8 @@ struct GTY(()) language_function { BOOL_BITFIELD invalid_constexpr : 1; - hash_table *x_named_labels; + hash_table *x_named_labels; + cp_binding_level *bindings; vec *x_local_names; /* Tracking possibly infinite loops. This is a vec only because Index: decl.c =================================================================== --- decl.c (revision 254086) +++ decl.c (working copy) @@ -189,27 +189,33 @@ struct GTY((chain_next ("%h.next"))) nam function, and so we can check the validity of jumps to these labels. */ struct GTY((for_user)) named_label_entry { - /* The decl itself. */ - tree label_decl; + + tree name; /* Name of decl. */ + + tree label_decl; /* LABEL_DECL, unless deleted local label. */ + + named_label_entry *outer; /* Outer shadowed chain. */ /* The binding level to which the label is *currently* attached. This is initially set to the binding level in which the label is defined, but is modified as scopes are closed. */ cp_binding_level *binding_level; + /* The head of the names list that was current when the label was defined, or the inner scope popped. These are the decls that will be skipped when jumping to the label. */ tree names_in_scope; + /* A vector of all decls from all binding levels that would be crossed by a backward branch to the label. */ vec *bad_decls; /* A list of uses of the label, before the label is defined. */ - struct named_label_use_entry *uses; + named_label_use_entry *uses; /* The following bits are set after the label is defined, and are - updated as scopes are popped. They indicate that a backward jump - to the label will illegally enter a scope of the given flavor. */ + updated as scopes are popped. They indicate that a jump to the + label will illegally enter a scope of the given flavor. */ bool in_try_scope; bool in_catch_scope; bool in_omp_scope; @@ -347,7 +353,7 @@ finish_scope (void) in a valid manner, and issue any appropriate warnings or errors. */ static void -pop_label (tree label, tree old_value) +check_label_used (tree label) { if (!processing_template_decl) { @@ -364,32 +370,6 @@ pop_label (tree label, tree old_value) else warn_for_unused_label (label); } - - SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value); -} - -/* Push all named labels into a vector, so that we can sort it on DECL_UID - to avoid code generation differences. */ - -int -note_label (named_label_entry **slot, vec &labels) -{ - labels.quick_push (slot); - return 1; -} - -/* Helper function to sort named label entries in a vector by DECL_UID. */ - -static int -sort_labels (const void *a, const void *b) -{ - named_label_entry **slot1 = *(named_label_entry **const *) a; - named_label_entry **slot2 = *(named_label_entry **const *) b; - if (DECL_UID ((*slot1)->label_decl) < DECL_UID ((*slot2)->label_decl)) - return -1; - if (DECL_UID ((*slot1)->label_decl) > DECL_UID ((*slot2)->label_decl)) - return 1; - return 0; } /* At the end of a function, all labels declared within the function @@ -399,46 +379,49 @@ sort_labels (const void *a, const void * static void pop_labels (tree block) { - if (named_labels) + if (!named_labels) + return; + + hash_table::iterator end (named_labels->end ()); + for (hash_table::iterator iter + (named_labels->begin ()); iter != end; ++iter) { - auto_vec labels; - named_label_entry **slot; - unsigned int i; + named_label_entry *ent = *iter; - /* Push all the labels into a vector and sort them by DECL_UID, - so that gaps between DECL_UIDs don't affect code generation. */ - labels.reserve_exact (named_labels->elements ()); - named_labels->traverse &, note_label> (labels); - labels.qsort (sort_labels); - FOR_EACH_VEC_ELT (labels, i, slot) + gcc_checking_assert (!ent->outer); + if (ent->label_decl) { - struct named_label_entry *ent = *slot; - - pop_label (ent->label_decl, NULL_TREE); + check_label_used (ent->label_decl); /* Put the labels into the "variables" of the top-level block, so debugger can see them. */ DECL_CHAIN (ent->label_decl) = BLOCK_VARS (block); BLOCK_VARS (block) = ent->label_decl; - - named_labels->clear_slot (slot); } - named_labels = NULL; + ggc_free (ent); } + + named_labels = NULL; } /* At the end of a block with local labels, restore the outer definition. */ static void -pop_local_label (tree label, tree old_value) +pop_local_label (tree id, tree label) { - struct named_label_entry dummy; - - pop_label (label, old_value); + check_label_used (label); + named_label_entry **slot = named_labels->find_slot_with_hash + (id, IDENTIFIER_HASH_VALUE (id), NO_INSERT); + named_label_entry *ent = *slot; - dummy.label_decl = label; - named_label_entry **slot = named_labels->find_slot (&dummy, NO_INSERT); - named_labels->clear_slot (slot); + if (ent->outer) + ent = ent->outer; + else + { + ent = ggc_cleared_alloc (); + ent->name = id; + } + *slot = ent; } /* The following two routines are used to interface to Objective-C++. @@ -579,7 +562,6 @@ poplevel (int keep, int reverse, int fun int leaving_for_scope; scope_kind kind; unsigned ix; - cp_label_binding *label_bind; bool subtime = timevar_cond_start (TV_NAME_LOOKUP); restart: @@ -613,11 +595,12 @@ poplevel (int keep, int reverse, int fun Usually current_binding_level->names is in reverse order. But parameter decls were previously put in forward order. */ + decls = current_binding_level->names; if (reverse) - current_binding_level->names - = decls = nreverse (current_binding_level->names); - else - decls = current_binding_level->names; + { + decls = nreverse (decls); + current_binding_level->names = decls; + } /* If there were any declarations or structure tags in that level, or if this level is a function body, @@ -770,7 +753,10 @@ poplevel (int keep, int reverse, int fun } } /* Remove the binding. */ - pop_local_binding (name, decl); + if (TREE_CODE (decl) == LABEL_DECL) + pop_local_label (name, decl); + else + pop_local_binding (name, decl); } /* Remove declarations for any `for' variables from inner scopes @@ -784,11 +770,6 @@ poplevel (int keep, int reverse, int fun link; link = TREE_CHAIN (link)) SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link)); - /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */ - FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level->shadowed_labels, - ix, label_bind) - pop_local_label (label_bind->label, label_bind->prev_value); - /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs list if a `using' declaration put them there. The debugging back ends won't understand OVERLOAD, so we remove them here. @@ -2949,81 +2930,83 @@ redeclaration_error_message (tree newdec } } + /* Hash and equality functions for the named_label table. */ hashval_t -named_label_hasher::hash (named_label_entry *ent) +named_label_hash::hash (const value_type entry) { - return DECL_UID (ent->label_decl); + return IDENTIFIER_HASH_VALUE (entry->name); } bool -named_label_hasher::equal (named_label_entry *a, named_label_entry *b) +named_label_hash::equal (const value_type entry, compare_type name) { - return a->label_decl == b->label_decl; + return name == entry->name; } -/* Create a new label, named ID. */ +/* Look for a label named ID in the current function. If one cannot + be found, create one. Return the named_label_entry, or NULL on + failure. */ -static tree -make_label_decl (tree id, int local_p) +static named_label_entry * +lookup_label_1 (tree id, bool making_local_p) { - struct named_label_entry *ent; - tree decl; - - decl = build_decl (input_location, LABEL_DECL, id, void_type_node); - - DECL_CONTEXT (decl) = current_function_decl; - SET_DECL_MODE (decl, VOIDmode); - C_DECLARED_LABEL_FLAG (decl) = local_p; - - /* Say where one reference is to the label, for the sake of the - error if it is not defined. */ - DECL_SOURCE_LOCATION (decl) = input_location; - - /* Record the fact that this identifier is bound to this label. */ - SET_IDENTIFIER_LABEL_VALUE (id, decl); + /* You can't use labels at global scope. */ + if (current_function_decl == NULL_TREE) + { + error ("label %qE referenced outside of any function", id); + return NULL; + } - /* Create the label htab for the function on demand. */ if (!named_labels) - named_labels = hash_table::create_ggc (13); - - /* Record this label on the list of labels used in this function. - We do this before calling make_label_decl so that we get the - IDENTIFIER_LABEL_VALUE before the new label is declared. */ - ent = ggc_cleared_alloc (); - ent->label_decl = decl; + named_labels = hash_table::create_ggc (13); - named_label_entry **slot = named_labels->find_slot (ent, INSERT); - gcc_assert (*slot == NULL); - *slot = ent; + hashval_t hash = IDENTIFIER_HASH_VALUE (id); + named_label_entry **slot + = named_labels->find_slot_with_hash (id, hash, INSERT); + named_label_entry *old = *slot; + + if (old && old->label_decl) + { + if (!making_local_p) + return old; - return decl; -} + if (old->binding_level == current_binding_level) + { + error ("local label %qE conflicts with existing label", id); + inform (DECL_SOURCE_LOCATION (old->label_decl), "previous label"); + return NULL; + } + } -/* Look for a label named ID in the current function. If one cannot - be found, create one. (We keep track of used, but undefined, - labels, and complain about them at the end of a function.) */ + /* We are making a new decl, create or reuse the named_label_entry */ + named_label_entry *ent = NULL; + if (old && !old->label_decl) + ent = old; + else + { + ent = ggc_cleared_alloc (); + ent->name = id; + ent->outer = old; + *slot = ent; + } -static tree -lookup_label_1 (tree id) -{ - tree decl; + /* Now create the LABEL_DECL. */ + tree decl = build_decl (input_location, LABEL_DECL, id, void_type_node); - /* You can't use labels at global scope. */ - if (current_function_decl == NULL_TREE) + DECL_CONTEXT (decl) = current_function_decl; + SET_DECL_MODE (decl, VOIDmode); + if (making_local_p) { - error ("label %qE referenced outside of any function", id); - return NULL_TREE; + C_DECLARED_LABEL_FLAG (decl) = true; + DECL_CHAIN (decl) = current_binding_level->names; + current_binding_level->names = decl; } - /* See if we've already got this label. */ - decl = IDENTIFIER_LABEL_VALUE (id); - if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl) - return decl; + ent->label_decl = decl; - decl = make_label_decl (id, /*local_p=*/0); - return decl; + return ent; } /* Wrapper for lookup_label_1. */ @@ -3031,30 +3014,19 @@ lookup_label_1 (tree id) tree lookup_label (tree id) { - tree ret; bool subtime = timevar_cond_start (TV_NAME_LOOKUP); - ret = lookup_label_1 (id); + named_label_entry *ent = lookup_label_1 (id, false); timevar_cond_stop (TV_NAME_LOOKUP, subtime); - return ret; + return ent ? ent->label_decl : NULL_TREE; } -/* Declare a local label named ID. */ - tree declare_local_label (tree id) { - tree decl; - cp_label_binding bind; - - /* Add a new entry to the SHADOWED_LABELS list so that when we leave - this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */ - bind.prev_value = IDENTIFIER_LABEL_VALUE (id); - - decl = make_label_decl (id, /*local_p=*/1); - bind.label = decl; - vec_safe_push (current_binding_level->shadowed_labels, bind); - - return decl; + bool subtime = timevar_cond_start (TV_NAME_LOOKUP); + named_label_entry *ent = lookup_label_1 (id, true); + timevar_cond_stop (TV_NAME_LOOKUP, subtime); + return ent ? ent->label_decl : NULL_TREE; } /* Returns nonzero if it is ill-formed to jump past the declaration of @@ -3232,8 +3204,6 @@ check_switch_goto (cp_binding_level* lev void check_goto (tree decl) { - struct named_label_entry *ent, dummy; - /* We can't know where a computed goto is jumping. So we assume that it's OK. */ if (TREE_CODE (decl) != LABEL_DECL) @@ -3244,22 +3214,22 @@ check_goto (tree decl) if (decl == cdtor_label) return; - dummy.label_decl = decl; - ent = named_labels->find (&dummy); - gcc_assert (ent != NULL); + hashval_t hash = IDENTIFIER_HASH_VALUE (DECL_NAME (decl)); + named_label_entry **slot + = named_labels->find_slot_with_hash (DECL_NAME (decl), hash, NO_INSERT); + named_label_entry *ent = *slot; /* If the label hasn't been defined yet, defer checking. */ if (! DECL_INITIAL (decl)) { - struct named_label_use_entry *new_use; - /* Don't bother creating another use if the last goto had the same data, and will therefore create the same set of errors. */ if (ent->uses && ent->uses->names_in_scope == current_binding_level->names) return; - new_use = ggc_alloc (); + named_label_use_entry *new_use + = ggc_alloc (); new_use->binding_level = current_binding_level; new_use->names_in_scope = current_binding_level->names; new_use->o_goto_locus = input_location; @@ -3378,25 +3348,15 @@ check_omp_return (void) static tree define_label_1 (location_t location, tree name) { - struct named_label_entry *ent, dummy; - cp_binding_level *p; - tree decl; - - decl = lookup_label (name); - - dummy.label_decl = decl; - ent = named_labels->find (&dummy); - gcc_assert (ent != NULL); - /* After labels, make any new cleanups in the function go into their own new (temporary) binding contour. */ - for (p = current_binding_level; + for (cp_binding_level *p = current_binding_level; p->kind != sk_function_parms; p = p->level_chain) p->more_cleanups_ok = 0; - if (name == get_identifier ("wchar_t")) - permerror (input_location, "label named wchar_t"); + named_label_entry *ent = lookup_label_1 (name, false); + tree decl = ent->label_decl; if (DECL_INITIAL (decl) != NULL_TREE) { Index: lex.c =================================================================== --- lex.c (revision 254086) +++ lex.c (working copy) @@ -585,7 +585,6 @@ make_conv_op_name (tree type) /* Just in case something managed to bind. */ IDENTIFIER_BINDING (identifier) = NULL; - IDENTIFIER_LABEL_VALUE (identifier) = NULL_TREE; /* Hang TYPE off the identifier so it can be found easily later when performing conversions. */ Index: name-lookup.h =================================================================== --- name-lookup.h (revision 254086) +++ name-lookup.h (working copy) @@ -148,15 +148,6 @@ struct GTY(()) cp_class_binding { tree identifier; }; - -struct GTY(()) cp_label_binding { - /* The bound LABEL_DECL. */ - tree label; - /* The previous IDENTIFIER_LABEL_VALUE. */ - tree prev_value; -}; - - /* For each binding contour we allocate a binding_level structure which records the names defined in that contour. Contours include: @@ -202,10 +193,6 @@ struct GTY(()) cp_binding_level { the class. */ tree type_shadowed; - /* Similar to class_shadowed, but for IDENTIFIER_LABEL_VALUE, and - used for all binding levels. */ - vec *shadowed_labels; - /* For each level (except not the global one), a chain of BLOCK nodes for all the levels that were entered and exited one level down. */ Index: ptree.c =================================================================== --- ptree.c (revision 254086) +++ ptree.c (working copy) @@ -177,7 +177,6 @@ cxx_print_identifier (FILE *file, tree n indent_to (file, indent + 4); fprintf (file, "%s local bindings <%p>", get_identifier_kind_name (node), (void *) IDENTIFIER_BINDING (node)); - print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4); } void