From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 32552 invoked by alias); 31 Aug 2013 17:14:50 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 32542 invoked by uid 89); 31 Aug 2013 17:14:49 -0000 Received: from cantor2.suse.de (HELO mx2.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 31 Aug 2013 17:14:49 +0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-3.8 required=5.0 tests=AWL,BAYES_00,KHOP_THREADED,RDNS_NONE autolearn=no version=3.3.2 X-HELO: mx2.suse.de Received: from relay1.suse.de (unknown [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id 2EF3BA41E0; Sat, 31 Aug 2013 19:14:45 +0200 (CEST) User-Agent: K-9 Mail for Android In-Reply-To: <20130831162022.GB22772@kam.mff.cuni.cz> References: <20130831162022.GB22772@kam.mff.cuni.cz> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Subject: Re: Remove hash from remember_with_vars From: Richard Biener Date: Sat, 31 Aug 2013 17:26:00 -0000 To: Jan Hubicka , gcc-patches@gcc.gnu.org Message-ID: <301dcb70-d7b5-4ad1-89fe-a20d5a78fba7@email.android.com> X-SW-Source: 2013-08/txt/msg01968.txt.bz2 Jan Hubicka wrote: >Hi, >remember_with_vars walks trees that are read from file (now unique) >and looks for fields that can contain pointers to vars or functions and >if so, it records them to global hashtable for later fixup. >This is quite wasteful, because the hash is querried many times. >We can simply walk all fields in a tree and record the tree once >afterwards, >moreover since streaming knows when tree is newly constructed, we don't >need >hash. > >Vectors do not allow deletable elements, but I think it makes no >difference: >the trees are all used from decl states. Heh, indeed a cleanup possibility I missed. Ok. Thanks, Richard. > * lot.c (tree_with_vars): Turn into vector. > (MAYBE_REMEMBER_WITH_VARS): Change to... > (CHECK_VAR): ... this one. > (CHECK_NO_VAR): New macro. > (maybe_remember_with_vars_typed): Trun to ... > (mentions_vars_p_typed): ... this one. > (maybe_remember_with_vars_common): Trun to ... > (mentions_vars_p_comon): ... this one. > (maybe_remember_with_vars_decl_minimal): Trun to ... > (mentions_vars_p_decl_minmal): ... this one. > (maybe_remember_with_vars_decl_common): Trun to ... > (mentions_vars_p_decl_common): ... this one. > (maybe_remember_with_vars_decl_with_vis): Trun to ... > (mentions_vars_p_decl_with_vis): ... this one. > (maybe_remember_with_vars_decl_non_common): Trun to ... > (mentions_vars_p_decl_non_common): ... this one. > (maybe_remember_with_vars_function): Trun to ... > (mentions_vars_p_function): ... this one. > (maybe_remember_with_vars_field_decl): Trun to ... > (mentions_vars_p_field_decl): ... this one. > (maybe_remember_with_vars_type): Trun to ... > (mentions_vars_p_type): ... this one. > (maybe_remember_with_vars_binfo): Trun to ... > (mentions_vars_p_binfo): ... this one. > (maybe_remember_with_vars_constructor): Trun to ... > (mentions_vars_p_constructor): ... this one. > (maybe_remember_with_vars_expr): Trun to ... > (mentions_vars_p_expr): ... this one. > (maybe_remember_with_vars): Trun to ... > (mentions_vars_p): ... this one. > (lto_read_decls): Update. > (LTO_SET_PREVAIL): Do not call function for internal decls. > (lto_fixup_prevailing_decls): Update to match mentions_vars_p; > check that something was updated. > (lto_fixup_state): Do not care about internal decls. > (lto_fixup_decls): Update. > (read_cgraph_and_symbols): Update. >Index: lto/lto.c >=================================================================== >--- lto/lto.c (revision 202099) >+++ lto/lto.c (working copy) >@@ -1283,196 +1286,206 @@ gimple_register_type (tree t) > > /* End of old merging code. */ > >+/* Remember trees that contains references to declarations. */ >+static GTY(()) vec *tree_with_vars; > >- >-/* A hashtable of trees that potentially refer to variables or >functions >- that must be replaced with their prevailing variant. */ >-static GTY((if_marked ("ggc_marked_p"), param_is (union tree_node))) >htab_t >- tree_with_vars; >- >-/* Remember that T is a tree that (potentially) refers to a variable >- or function decl that may be replaced with its prevailing variant. >*/ >-static void >-remember_with_vars (tree t) >-{ >- *(tree *) htab_find_slot (tree_with_vars, t, INSERT) = t; >-} >- >-#define MAYBE_REMEMBER_WITH_VARS(tt) \ >+#define CHECK_VAR(tt) \ > do \ > { \ >- if (tt) \ >- { \ >- if (VAR_OR_FUNCTION_DECL_P (tt) && TREE_PUBLIC (tt)) \ >- remember_with_vars (t); \ >- } \ >+ if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \ >+ && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \ >+ return true; \ > } while (0) > >-/* Fix up fields of a tree_typed T. */ >+#define CHECK_NO_VAR(tt) \ >+ gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt)) > >-static void >-maybe_remember_with_vars_typed (tree t) >+/* Check presence of pointers to decls in fields of a tree_typed T. >*/ >+ >+static inline bool >+mentions_vars_p_typed (tree t) > { >- MAYBE_REMEMBER_WITH_VARS (TREE_TYPE (t)); >+ CHECK_NO_VAR (TREE_TYPE (t)); >+ return false; > } > >-/* Fix up fields of a tree_common T. */ >+/* Check presence of pointers to decls in fields of a tree_common T. >*/ > >-static void >-maybe_remember_with_vars_common (tree t) >+static inline bool >+mentions_vars_p_common (tree t) > { >- maybe_remember_with_vars_typed (t); >- MAYBE_REMEMBER_WITH_VARS (TREE_CHAIN (t)); >+ if (mentions_vars_p_typed (t)) >+ return true; >+ CHECK_NO_VAR (TREE_CHAIN (t)); >+ return false; > } > >-/* Fix up fields of a decl_minimal T. */ >+/* Check presence of pointers to decls in fields of a decl_minimal T. >*/ > >-static void >-maybe_remember_with_vars_decl_minimal (tree t) >+static inline bool >+mentions_vars_p_decl_minimal (tree t) > { >- maybe_remember_with_vars_common (t); >- MAYBE_REMEMBER_WITH_VARS (DECL_NAME (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_CONTEXT (t)); >+ if (mentions_vars_p_common (t)) >+ return true; >+ CHECK_NO_VAR (DECL_NAME (t)); >+ CHECK_VAR (DECL_CONTEXT (t)); >+ return false; > } > >-/* Fix up fields of a decl_common T. */ >+/* Check presence of pointers to decls in fields of a decl_common T. >*/ > >-static void >-maybe_remember_with_vars_decl_common (tree t) >+static inline bool >+mentions_vars_p_decl_common (tree t) > { >- maybe_remember_with_vars_decl_minimal (t); >- MAYBE_REMEMBER_WITH_VARS (DECL_SIZE (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_SIZE_UNIT (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_INITIAL (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_ATTRIBUTES (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_ABSTRACT_ORIGIN (t)); >+ if (mentions_vars_p_decl_minimal (t)) >+ return true; >+ CHECK_VAR (DECL_SIZE (t)); >+ CHECK_VAR (DECL_SIZE_UNIT (t)); >+ CHECK_VAR (DECL_INITIAL (t)); >+ CHECK_NO_VAR (DECL_ATTRIBUTES (t)); >+ CHECK_VAR (DECL_ABSTRACT_ORIGIN (t)); >+ return false; > } > >-/* Fix up fields of a decl_with_vis T. */ >+/* Check presence of pointers to decls in fields of a decl_with_vis T. > */ > >-static void >-maybe_remember_with_vars_decl_with_vis (tree t) >+static inline bool >+mentions_vars_p_decl_with_vis (tree t) > { >- maybe_remember_with_vars_decl_common (t); >+ if (mentions_vars_p_decl_common (t)) >+ return true; > > /* Accessor macro has side-effects, use field-name here. */ >- MAYBE_REMEMBER_WITH_VARS (t->decl_with_vis.assembler_name); >- MAYBE_REMEMBER_WITH_VARS (DECL_SECTION_NAME (t)); >+ CHECK_NO_VAR (t->decl_with_vis.assembler_name); >+ CHECK_NO_VAR (DECL_SECTION_NAME (t)); >+ return false; > } > >-/* Fix up fields of a decl_non_common T. */ >+/* Check presence of pointers to decls in fields of a decl_non_common >T. */ > >-static void >-maybe_remember_with_vars_decl_non_common (tree t) >+static inline bool >+mentions_vars_p_decl_non_common (tree t) > { >- maybe_remember_with_vars_decl_with_vis (t); >- MAYBE_REMEMBER_WITH_VARS (DECL_ARGUMENT_FLD (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_RESULT_FLD (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_VINDEX (t)); >+ if (mentions_vars_p_decl_with_vis (t)) >+ return true; >+ CHECK_NO_VAR (DECL_ARGUMENT_FLD (t)); >+ CHECK_NO_VAR (DECL_RESULT_FLD (t)); >+ CHECK_NO_VAR (DECL_VINDEX (t)); >+ return false; > } > >-/* Fix up fields of a decl_non_common T. */ >+/* Check presence of pointers to decls in fields of a decl_non_common >T. */ > >-static void >-maybe_remember_with_vars_function (tree t) >+static bool >+mentions_vars_p_function (tree t) > { >- maybe_remember_with_vars_decl_non_common (t); >- MAYBE_REMEMBER_WITH_VARS (DECL_FUNCTION_PERSONALITY (t)); >+ if (mentions_vars_p_decl_non_common (t)) >+ return true; >+ CHECK_VAR (DECL_FUNCTION_PERSONALITY (t)); >+ return false; > } > >-/* Fix up fields of a field_decl T. */ >+/* Check presence of pointers to decls in fields of a field_decl T. >*/ > >-static void >-maybe_remember_with_vars_field_decl (tree t) >+static bool >+mentions_vars_p_field_decl (tree t) > { >- maybe_remember_with_vars_decl_common (t); >- MAYBE_REMEMBER_WITH_VARS (DECL_FIELD_OFFSET (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_BIT_FIELD_TYPE (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_QUALIFIER (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_FIELD_BIT_OFFSET (t)); >- MAYBE_REMEMBER_WITH_VARS (DECL_FCONTEXT (t)); >+ if (mentions_vars_p_decl_common (t)) >+ return true; >+ CHECK_NO_VAR (DECL_FIELD_OFFSET (t)); >+ CHECK_NO_VAR (DECL_BIT_FIELD_TYPE (t)); >+ CHECK_NO_VAR (DECL_QUALIFIER (t)); >+ CHECK_NO_VAR (DECL_FIELD_BIT_OFFSET (t)); >+ CHECK_NO_VAR (DECL_FCONTEXT (t)); >+ return false; > } > >-/* Fix up fields of a type T. */ >+/* Check presence of pointers to decls in fields of a type T. */ > >-static void >-maybe_remember_with_vars_type (tree t) >+static bool >+mentions_vars_p_type (tree t) > { >- maybe_remember_with_vars_common (t); >- MAYBE_REMEMBER_WITH_VARS (TYPE_CACHED_VALUES (t)); >- MAYBE_REMEMBER_WITH_VARS (TYPE_SIZE (t)); >- MAYBE_REMEMBER_WITH_VARS (TYPE_SIZE_UNIT (t)); >- MAYBE_REMEMBER_WITH_VARS (TYPE_ATTRIBUTES (t)); >- MAYBE_REMEMBER_WITH_VARS (TYPE_NAME (t)); >- >- /* Accessors are for derived node types only. */ >- if (!POINTER_TYPE_P (t)) >- MAYBE_REMEMBER_WITH_VARS (TYPE_MINVAL (t)); >- MAYBE_REMEMBER_WITH_VARS (TYPE_MAXVAL (t)); >+ if (mentions_vars_p_common (t)) >+ return true; >+ CHECK_NO_VAR (TYPE_CACHED_VALUES (t)); >+ CHECK_VAR (TYPE_SIZE (t)); >+ CHECK_VAR (TYPE_SIZE_UNIT (t)); >+ CHECK_NO_VAR (TYPE_ATTRIBUTES (t)); >+ CHECK_NO_VAR (TYPE_NAME (t)); >+ >+ CHECK_VAR (TYPE_MINVAL (t)); >+ CHECK_VAR (TYPE_MAXVAL (t)); > > /* Accessor is for derived node types only. */ >- MAYBE_REMEMBER_WITH_VARS (t->type_non_common.binfo); >+ CHECK_NO_VAR (t->type_non_common.binfo); > >- MAYBE_REMEMBER_WITH_VARS (TYPE_CONTEXT (t)); >+ CHECK_VAR (TYPE_CONTEXT (t)); >+ CHECK_NO_VAR (TYPE_CANONICAL (t)); >+ CHECK_NO_VAR (TYPE_MAIN_VARIANT (t)); >+ CHECK_NO_VAR (TYPE_NEXT_VARIANT (t)); >+ return false; > } > >-/* Fix up fields of a BINFO T. */ >+/* Check presence of pointers to decls in fields of a BINFO T. */ > >-static void >-maybe_remember_with_vars_binfo (tree t) >+static bool >+mentions_vars_p_binfo (tree t) > { > unsigned HOST_WIDE_INT i, n; > >- maybe_remember_with_vars_common (t); >- MAYBE_REMEMBER_WITH_VARS (BINFO_VTABLE (t)); >- MAYBE_REMEMBER_WITH_VARS (BINFO_OFFSET (t)); >- MAYBE_REMEMBER_WITH_VARS (BINFO_VIRTUALS (t)); >- MAYBE_REMEMBER_WITH_VARS (BINFO_VPTR_FIELD (t)); >+ if (mentions_vars_p_common (t)) >+ return true; >+ CHECK_VAR (BINFO_VTABLE (t)); >+ CHECK_NO_VAR (BINFO_OFFSET (t)); >+ CHECK_NO_VAR (BINFO_VIRTUALS (t)); >+ CHECK_NO_VAR (BINFO_VPTR_FIELD (t)); > n = vec_safe_length (BINFO_BASE_ACCESSES (t)); > for (i = 0; i < n; i++) >- MAYBE_REMEMBER_WITH_VARS (BINFO_BASE_ACCESS (t, i)); >+ CHECK_NO_VAR (BINFO_BASE_ACCESS (t, i)); > /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX > and BINFO_VPTR_INDEX; these are used by C++ FE only. */ > n = BINFO_N_BASE_BINFOS (t); > for (i = 0; i < n; i++) >- MAYBE_REMEMBER_WITH_VARS (BINFO_BASE_BINFO (t, i)); >+ CHECK_NO_VAR (BINFO_BASE_BINFO (t, i)); >+ return false; > } > >-/* Fix up fields of a CONSTRUCTOR T. */ >+/* Check presence of pointers to decls in fields of a CONSTRUCTOR T. >*/ > >-static void >-maybe_remember_with_vars_constructor (tree t) >+static bool >+mentions_vars_p_constructor (tree t) > { > unsigned HOST_WIDE_INT idx; > constructor_elt *ce; > >- maybe_remember_with_vars_typed (t); >+ if (mentions_vars_p_typed (t)) >+ return true; > >for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t), idx, &ce); idx++) > { >- MAYBE_REMEMBER_WITH_VARS (ce->index); >- MAYBE_REMEMBER_WITH_VARS (ce->value); >+ CHECK_NO_VAR (ce->index); >+ CHECK_VAR (ce->value); > } >+ return false; > } > >-/* Fix up fields of an expression tree T. */ >+/* Check presence of pointers to decls in fields of an expression tree >T. */ > >-static void >-maybe_remember_with_vars_expr (tree t) >+static bool >+mentions_vars_p_expr (tree t) > { > int i; >- maybe_remember_with_vars_typed (t); >+ if (mentions_vars_p_typed (t)) >+ return true; > for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i) >- MAYBE_REMEMBER_WITH_VARS (TREE_OPERAND (t, i)); >+ CHECK_VAR (TREE_OPERAND (t, i)); >+ return false; > } > >-/* Given a tree T fixup fields of T by replacing types with their >merged >- variant and other entities by an equal entity from an earlier >compilation >- unit, or an entity being canonical in a different way. This >includes >- for instance integer or string constants. */ >+/* Check presence of pointers to decls that needs later fixup in T. >*/ > >-static void >-maybe_remember_with_vars (tree t) >+static bool >+mentions_vars_p (tree t) > { > switch (TREE_CODE (t)) > { >@@ -1480,13 +1493,13 @@ maybe_remember_with_vars (tree t) > break; > > case TREE_LIST: >- MAYBE_REMEMBER_WITH_VARS (TREE_VALUE (t)); >- MAYBE_REMEMBER_WITH_VARS (TREE_PURPOSE (t)); >- MAYBE_REMEMBER_WITH_VARS (TREE_CHAIN (t)); >+ CHECK_VAR (TREE_VALUE (t)); >+ CHECK_VAR (TREE_PURPOSE (t)); >+ CHECK_NO_VAR (TREE_CHAIN (t)); > break; > > case FIELD_DECL: >- maybe_remember_with_vars_field_decl (t); >+ return mentions_vars_p_field_decl (t); > break; > > case LABEL_DECL: >@@ -1494,27 +1507,28 @@ maybe_remember_with_vars (tree t) > case PARM_DECL: > case RESULT_DECL: > case IMPORTED_DECL: >- maybe_remember_with_vars_decl_common (t); >+ case NAMESPACE_DECL: >+ return mentions_vars_p_decl_common (t); > break; > > case VAR_DECL: >- maybe_remember_with_vars_decl_with_vis (t); >+ return mentions_vars_p_decl_with_vis (t); > break; > > case TYPE_DECL: >- maybe_remember_with_vars_decl_non_common (t); >+ return mentions_vars_p_decl_non_common (t); > break; > > case FUNCTION_DECL: >- maybe_remember_with_vars_function (t); >+ return mentions_vars_p_function (t); > break; > > case TREE_BINFO: >- maybe_remember_with_vars_binfo (t); >+ return mentions_vars_p_binfo (t); > break; > > case PLACEHOLDER_EXPR: >- maybe_remember_with_vars_common (t); >+ return mentions_vars_p_common (t); > break; > > case BLOCK: >@@ -1524,19 +1538,26 @@ maybe_remember_with_vars (tree t) > break; > > case CONSTRUCTOR: >- maybe_remember_with_vars_constructor (t); >+ return mentions_vars_p_constructor (t); > break; > > default: > if (TYPE_P (t)) >- maybe_remember_with_vars_type (t); >- else if (CONSTANT_CLASS_P (t)) >- MAYBE_REMEMBER_WITH_VARS (TREE_TYPE (t)); >+ { >+ if (mentions_vars_p_type (t)) >+ return true; >+ } > else if (EXPR_P (t)) >- maybe_remember_with_vars_expr (t); >+ { >+ if (mentions_vars_p_expr (t)) >+ return true; >+ } >+ else if (CONSTANT_CLASS_P (t)) >+ CHECK_NO_VAR (TREE_TYPE (t)); > else >- remember_with_vars (t); >+ gcc_unreachable (); > } >+ return false; > } > > >@@ -2492,7 +2513,8 @@ lto_read_decls (struct lto_file_decl_dat > lto_register_function_decl_in_symtab (data_in, t, from + i); > /* Scan the tree for references to global functions or > variables and record those for later fixup. */ >- maybe_remember_with_vars (t); >+ if (mentions_vars_p (t)) >+ vec_safe_push (tree_with_vars, t); > } > } > if (not_merged_type_same_scc) >@@ -3137,8 +3247,12 @@ lto_wpa_write_files (void) > prevailing variant. */ > #define LTO_SET_PREVAIL(tt) \ > do {\ >- if ((tt) && VAR_OR_FUNCTION_DECL_P (tt)) \ >- tt = lto_symtab_prevailing_decl (tt); \ >+ if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \ >+ && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \ >+ { \ >+ tt = lto_symtab_prevailing_decl (tt); \ >+ fixed = true; \ >+ } \ > } while (0) > > /* Ensure that TT isn't a replacable var of function decl. */ >@@ -3151,6 +3265,9 @@ static void > lto_fixup_prevailing_decls (tree t) > { > enum tree_code code = TREE_CODE (t); >+ bool fixed = false; >+ >+ gcc_checking_assert (code != CONSTRUCTOR && code != TREE_BINFO); > LTO_NO_PREVAIL (TREE_TYPE (t)); > if (CODE_CONTAINS_STRUCT (code, TS_COMMON)) > LTO_NO_PREVAIL (TREE_CHAIN (t)); >@@ -3198,7 +3315,7 @@ lto_fixup_prevailing_decls (tree t) > > LTO_SET_PREVAIL (TYPE_MINVAL (t)); > LTO_SET_PREVAIL (TYPE_MAXVAL (t)); >- LTO_SET_PREVAIL (t->type_non_common.binfo); >+ LTO_NO_PREVAIL (t->type_non_common.binfo); > > LTO_SET_PREVAIL (TYPE_CONTEXT (t)); > >@@ -3219,11 +3336,15 @@ lto_fixup_prevailing_decls (tree t) > case TREE_LIST: > LTO_SET_PREVAIL (TREE_VALUE (t)); > LTO_SET_PREVAIL (TREE_PURPOSE (t)); >+ LTO_NO_PREVAIL (TREE_PURPOSE (t)); > break; > default: > gcc_unreachable (); > } > } >+ /* If we fixed nothing, then we missed something seen by >+ mentions_vars_p. */ >+ gcc_checking_assert (fixed); > } > #undef LTO_SET_PREVAIL > #undef LTO_NO_PREVAIL >@@ -3246,7 +3368,8 @@ lto_fixup_state (struct lto_in_decl_stat > for (i = 0; i < table->size; i++) > { > tree *tp = table->trees + i; >- if (VAR_OR_FUNCTION_DECL_P (*tp)) >+ if (VAR_OR_FUNCTION_DECL_P (*tp) >+ && (TREE_PUBLIC (*tp) || DECL_EXTERNAL (*tp))) > *tp = lto_symtab_prevailing_decl (*tp); > } > } >@@ -3270,11 +3393,11 @@ static void > lto_fixup_decls (struct lto_file_decl_data **files) > { > unsigned int i; >- htab_iterator hi; > tree t; > >+ if (tree_with_vars) >+ FOR_EACH_VEC_ELT ((*tree_with_vars), i, t) >+ lto_fixup_prevailing_decls (t); >- htab_iterator hi; >- FOR_EACH_HTAB_ELEMENT (tree_with_vars, t, tree, hi) >- lto_fixup_prevailing_decls (t); > > for (i = 0; files[i]; i++) > { >@@ -3364,8 +3491,6 @@ read_cgraph_and_symbols (unsigned nfiles > } > cgraph_state = CGRAPH_LTO_STREAMING; > >- tree_with_vars = htab_create_ggc (101, htab_hash_pointer, >htab_eq_pointer, >- NULL); > type_hash_cache = htab_create_ggc (512, tree_int_map_hash, > tree_int_map_eq, NULL); >type_pair_cache = XCNEWVEC (struct type_pair_d, GIMPLE_TYPE_PAIR_SIZE); >@@ -3481,9 +3605,10 @@ read_cgraph_and_symbols (unsigned nfiles > /* Fixup all decls. */ > lto_fixup_decls (all_file_decl_data); > } >- htab_delete (tree_with_vars); >+ if (tree_with_vars) >+ ggc_free (tree_with_vars); > tree_with_vars = NULL; > ggc_collect (); > > timevar_pop (TV_IPA_LTO_DECL_MERGE); > /* Each pass will set the appropriate timer. */