diff options
| author | Trevor Saunders <tsaunders@mozilla.com> | 2014-06-24 13:21:35 +0000 |
|---|---|---|
| committer | Trevor Saunders <tbsaunde@gcc.gnu.org> | 2014-06-24 13:21:35 +0000 |
| commit | c203e8a73b2f12a1da52a16a0c4a50e62b42445b (patch) | |
| tree | b8d7f5b21a14b16949ddbc5dcaeb5f2b2654d63a | |
| parent | fbc2a724d481bb5c205baeaaa955533451226d01 (diff) | |
| download | gcc-c203e8a73b2f12a1da52a16a0c4a50e62b42445b.tar.gz | |
Remove a layer of indirection from hash_table
gcc/
* hash-table.h: Remove a layer of indirection from hash_table so that
it contains the hash table's data instead of a pointer to the data.
* alloc-pool.c, asan.c, attribs.c, bitmap.c, cfg.c,
config/arm/arm.c, config/i386/winnt.c, config/ia64/ia64.c,
config/mips/mips.c, config/sol2.c, coverage.c, cselib.c,
data-streamer-out.c, dse.c, dwarf2cfi.c, dwarf2out.c, except.c,
fold-const.c, gcse.c, ggc-common.c,
gimple-ssa-strength-reduction.c, gimplify.c,
graphite-clast-to-gimple.c, graphite-dependences.c,
graphite-htab.h, graphite.c, haifa-sched.c, ipa-devirt.c,
ipa-profile.c, ira-color.c, ira-costs.c, loop-invariant.c,
loop-iv.c, loop-unroll.c, lto-streamer-in.c, lto-streamer-out.c,
lto-streamer.c, lto-streamer.h, passes.c, plugin.c,
postreload-gcse.c, sese.c, statistics.c, store-motion.c,
trans-mem.c, tree-browser.c, tree-cfg.c, tree-complex.c,
tree-eh.c, tree-into-ssa.c, tree-parloops.c, tree-sra.c,
tree-ssa-ccp.c, tree-ssa-coalesce.c, tree-ssa-dom.c,
tree-ssa-live.c, tree-ssa-loop-im.c,
tree-ssa-loop-ivopts.c, tree-ssa-phiopt.c, tree-ssa-pre.c,
tree-ssa-reassoc.c, tree-ssa-sccvn.c, tree-ssa-strlen.c,
tree-ssa-structalias.c, tree-ssa-tail-merge.c,
tree-ssa-threadupdate.c, tree-ssa-uncprop.c,
tree-vect-data-refs.c, tree-vect-loop.c, tree-vectorizer.c,
tree-vectorizer.h, valtrack.c, valtrack.h, var-tracking.c,
vtable-verify.c, vtable-verify.h: Adjust.
gcc/c/
* c-decl.c: Adjust.
gcc/cp/
* class.c, semantics.c, tree.c, vtable-class-hierarchy.c:
Adjust.
gcc/java/
* jcf-io.c: Adjust.
gcc/lto/
* lto.c: Adjust.
gcc/objc/
* objc-act.c: Adjust.
From-SVN: r211936
91 files changed, 1361 insertions, 1506 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 15e16bf877f..ca591a66305 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,31 @@ +2014-06-24 Trevor Saunders <tsaunders@mozilla.com> + + * hash-table.h: Remove a layer of indirection from hash_table so that + it contains the hash table's data instead of a pointer to the data. + * alloc-pool.c, asan.c, attribs.c, bitmap.c, cfg.c, + config/arm/arm.c, config/i386/winnt.c, config/ia64/ia64.c, + config/mips/mips.c, config/sol2.c, coverage.c, cselib.c, + data-streamer-out.c, dse.c, dwarf2cfi.c, dwarf2out.c, except.c, + fold-const.c, gcse.c, ggc-common.c, + gimple-ssa-strength-reduction.c, gimplify.c, + graphite-clast-to-gimple.c, graphite-dependences.c, + graphite-htab.h, graphite.c, haifa-sched.c, ipa-devirt.c, + ipa-profile.c, ira-color.c, ira-costs.c, loop-invariant.c, + loop-iv.c, loop-unroll.c, lto-streamer-in.c, lto-streamer-out.c, + lto-streamer.c, lto-streamer.h, passes.c, plugin.c, + postreload-gcse.c, sese.c, statistics.c, store-motion.c, + trans-mem.c, tree-browser.c, tree-cfg.c, tree-complex.c, + tree-eh.c, tree-into-ssa.c, tree-parloops.c, tree-sra.c, + tree-ssa-ccp.c, tree-ssa-coalesce.c, tree-ssa-dom.c, + tree-ssa-live.c, tree-ssa-loop-im.c, + tree-ssa-loop-ivopts.c, tree-ssa-phiopt.c, tree-ssa-pre.c, + tree-ssa-reassoc.c, tree-ssa-sccvn.c, tree-ssa-strlen.c, + tree-ssa-structalias.c, tree-ssa-tail-merge.c, + tree-ssa-threadupdate.c, tree-ssa-uncprop.c, +tree-vect-data-refs.c, tree-vect-loop.c, tree-vectorizer.c, +tree-vectorizer.h, valtrack.c, valtrack.h, var-tracking.c, +vtable-verify.c, vtable-verify.h: Adjust. + 2014-06-24 Richard Biener <rguenther@suse.de> PR tree-optimization/61572 diff --git a/gcc/alloc-pool.c b/gcc/alloc-pool.c index 1713011808f..49209ee6845 100644 --- a/gcc/alloc-pool.c +++ b/gcc/alloc-pool.c @@ -105,7 +105,7 @@ alloc_pool_hasher::equal (const value_type *d, } /* Hashtable mapping alloc_pool names to descriptors. */ -static hash_table <alloc_pool_hasher> alloc_pool_hash; +static hash_table<alloc_pool_hasher> *alloc_pool_hash; /* For given name, return descriptor, create new if needed. */ static struct alloc_pool_descriptor * @@ -113,11 +113,12 @@ allocate_pool_descriptor (const char *name) { struct alloc_pool_descriptor **slot; - if (!alloc_pool_hash.is_created ()) - alloc_pool_hash.create (10); + if (!alloc_pool_hash) + alloc_pool_hash = new hash_table<alloc_pool_hasher> (10); - slot = alloc_pool_hash.find_slot_with_hash (name, - htab_hash_pointer (name), INSERT); + slot = alloc_pool_hash->find_slot_with_hash (name, + htab_hash_pointer (name), + INSERT); if (*slot) return *slot; *slot = XCNEW (struct alloc_pool_descriptor); @@ -404,15 +405,15 @@ dump_alloc_pool_statistics (void) if (! GATHER_STATISTICS) return; - if (!alloc_pool_hash.is_created ()) + if (!alloc_pool_hash) return; fprintf (stderr, "\nAlloc-pool Kind Elt size Pools Allocated (elts) Peak (elts) Leak (elts)\n"); fprintf (stderr, "--------------------------------------------------------------------------------------------------------------\n"); info.total_created = 0; info.total_allocated = 0; - alloc_pool_hash.traverse <struct output_info *, - print_alloc_pool_statistics> (&info); + alloc_pool_hash->traverse <struct output_info *, + print_alloc_pool_statistics> (&info); fprintf (stderr, "--------------------------------------------------------------------------------------------------------------\n"); fprintf (stderr, "%-22s %7lu %10lu\n", "Total", info.total_created, info.total_allocated); diff --git a/gcc/asan.c b/gcc/asan.c index eee1a71e8da..9eeafa897cf 100644 --- a/gcc/asan.c +++ b/gcc/asan.c @@ -363,18 +363,18 @@ asan_mem_ref_hasher::equal (const asan_mem_ref *m1, && operand_equal_p (m1->start, m2->start, 0)); } -static hash_table <asan_mem_ref_hasher> asan_mem_ref_ht; +static hash_table<asan_mem_ref_hasher> *asan_mem_ref_ht; /* Returns a reference to the hash table containing memory references. This function ensures that the hash table is created. Note that this hash table is updated by the function update_mem_ref_hash_table. */ -static hash_table <asan_mem_ref_hasher> & +static hash_table<asan_mem_ref_hasher> * get_mem_ref_hash_table () { - if (!asan_mem_ref_ht.is_created ()) - asan_mem_ref_ht.create (10); + if (!asan_mem_ref_ht) + asan_mem_ref_ht = new hash_table<asan_mem_ref_hasher> (10); return asan_mem_ref_ht; } @@ -384,8 +384,8 @@ get_mem_ref_hash_table () static void empty_mem_ref_hash_table () { - if (asan_mem_ref_ht.is_created ()) - asan_mem_ref_ht.empty (); + if (asan_mem_ref_ht) + asan_mem_ref_ht->empty (); } /* Free the memory references hash table. */ @@ -393,8 +393,8 @@ empty_mem_ref_hash_table () static void free_mem_ref_resources () { - if (asan_mem_ref_ht.is_created ()) - asan_mem_ref_ht.dispose (); + delete asan_mem_ref_ht; + asan_mem_ref_ht = NULL; if (asan_mem_ref_alloc_pool) { @@ -411,7 +411,7 @@ has_mem_ref_been_instrumented (tree ref, HOST_WIDE_INT access_size) asan_mem_ref r; asan_mem_ref_init (&r, ref, access_size); - return (get_mem_ref_hash_table ().find (&r) != NULL); + return (get_mem_ref_hash_table ()->find (&r) != NULL); } /* Return true iff the memory reference REF has been instrumented. */ @@ -858,12 +858,12 @@ has_stmt_been_instrumented_p (gimple stmt) static void update_mem_ref_hash_table (tree ref, HOST_WIDE_INT access_size) { - hash_table <asan_mem_ref_hasher> ht = get_mem_ref_hash_table (); + hash_table<asan_mem_ref_hasher> *ht = get_mem_ref_hash_table (); asan_mem_ref r; asan_mem_ref_init (&r, ref, access_size); - asan_mem_ref **slot = ht.find_slot (&r, INSERT); + asan_mem_ref **slot = ht->find_slot (&r, INSERT); if (*slot == NULL) *slot = asan_mem_ref_new (ref, access_size); } diff --git a/gcc/attribs.c b/gcc/attribs.c index 54373eb52ff..427a0f63f3d 100644 --- a/gcc/attribs.c +++ b/gcc/attribs.c @@ -85,7 +85,7 @@ struct scoped_attributes { const char *ns; vec<attribute_spec> attributes; - hash_table <attribute_hasher> attribute_hash; + hash_table<attribute_hasher> *attribute_hash; }; /* The table of scope attributes. */ @@ -144,7 +144,7 @@ register_scoped_attributes (const struct attribute_spec * attributes, sa.ns = ns; sa.attributes.create (64); result = attributes_table.safe_push (sa); - result->attribute_hash.create (200); + result->attribute_hash = new hash_table<attribute_hasher> (200); } /* Really add the attributes to their namespace now. */ @@ -281,7 +281,7 @@ register_scoped_attribute (const struct attribute_spec *attr, gcc_assert (attr != NULL && name_space != NULL); - gcc_assert (name_space->attribute_hash.is_created ()); + gcc_assert (name_space->attribute_hash); str.str = attr->name; str.length = strlen (str.str); @@ -291,8 +291,8 @@ register_scoped_attribute (const struct attribute_spec *attr, gcc_assert (str.length > 0 && str.str[0] != '_'); slot = name_space->attribute_hash - .find_slot_with_hash (&str, substring_hash (str.str, str.length), - INSERT); + ->find_slot_with_hash (&str, substring_hash (str.str, str.length), + INSERT); gcc_assert (!*slot || attr->name[0] == '*'); *slot = CONST_CAST (struct attribute_spec *, attr); } @@ -316,8 +316,9 @@ lookup_scoped_attribute_spec (const_tree ns, const_tree name) attr.str = IDENTIFIER_POINTER (name); attr.length = IDENTIFIER_LENGTH (name); extract_attribute_substring (&attr); - return attrs->attribute_hash.find_with_hash (&attr, - substring_hash (attr.str, attr.length)); + return attrs->attribute_hash->find_with_hash (&attr, + substring_hash (attr.str, + attr.length)); } /* Return the spec for the attribute named NAME. If NAME is a TREE_LIST, diff --git a/gcc/bitmap.c b/gcc/bitmap.c index 4f0143316b7..5f342d4666b 100644 --- a/gcc/bitmap.c +++ b/gcc/bitmap.c @@ -80,7 +80,7 @@ bitmap_desc_hasher::equal (const value_type *d, const compare_type *l) } /* Hashtable mapping bitmap names to descriptors. */ -static hash_table <bitmap_desc_hasher> bitmap_desc_hash; +static hash_table<bitmap_desc_hasher> *bitmap_desc_hash; /* For given file and line, return descriptor, create new if needed. */ static bitmap_descriptor @@ -93,12 +93,13 @@ get_bitmap_descriptor (const char *file, int line, const char *function) loc.function = function; loc.line = line; - if (!bitmap_desc_hash.is_created ()) - bitmap_desc_hash.create (10); + if (!bitmap_desc_hash) + bitmap_desc_hash = new hash_table<bitmap_desc_hasher> (10); - slot = bitmap_desc_hash.find_slot_with_hash (&loc, - htab_hash_pointer (file) + line, - INSERT); + slot + = bitmap_desc_hash->find_slot_with_hash (&loc, + htab_hash_pointer (file) + line, + INSERT); if (*slot) return *slot; @@ -2185,7 +2186,7 @@ dump_bitmap_statistics (void) if (! GATHER_STATISTICS) return; - if (!bitmap_desc_hash.is_created ()) + if (!bitmap_desc_hash) return; fprintf (stderr, @@ -2196,7 +2197,7 @@ dump_bitmap_statistics (void) fprintf (stderr, "---------------------------------------------------------------------------------\n"); info.count = 0; info.size = 0; - bitmap_desc_hash.traverse <output_info *, print_statistics> (&info); + bitmap_desc_hash->traverse <output_info *, print_statistics> (&info); fprintf (stderr, "---------------------------------------------------------------------------------\n"); fprintf (stderr, "%-41s %9"PRId64" %15"PRId64"\n", diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index c9372614122..4ab71603c5d 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,7 @@ +2014-06-24 Trevor Saunders <tsaunders@mozilla.com> + + * c-decl.c: Adjust. + 2014-06-24 Jakub Jelinek <jakub@redhat.com> * c-parser.c (c_parser_omp_for_loop): For diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c index 34560308b83..def10a2e2de 100644 --- a/gcc/c/c-decl.c +++ b/gcc/c/c-decl.c @@ -7076,7 +7076,7 @@ is_duplicate_field (tree x, tree y) static void detect_field_duplicates_hash (tree fieldlist, - hash_table <pointer_hash <tree_node> > htab) + hash_table<pointer_hash <tree_node> > *htab) { tree x, y; tree_node **slot; @@ -7084,7 +7084,7 @@ detect_field_duplicates_hash (tree fieldlist, for (x = fieldlist; x ; x = DECL_CHAIN (x)) if ((y = DECL_NAME (x)) != 0) { - slot = htab.find_slot (y, INSERT); + slot = htab->find_slot (y, INSERT); if (*slot) { error ("duplicate member %q+D", x); @@ -7104,7 +7104,7 @@ detect_field_duplicates_hash (tree fieldlist, && TREE_CODE (TYPE_NAME (TREE_TYPE (x))) == TYPE_DECL) { tree xn = DECL_NAME (TYPE_NAME (TREE_TYPE (x))); - slot = htab.find_slot (xn, INSERT); + slot = htab->find_slot (xn, INSERT); if (*slot) error ("duplicate member %q+D", TYPE_NAME (TREE_TYPE (x))); *slot = xn; @@ -7176,11 +7176,8 @@ detect_field_duplicates (tree fieldlist) } else { - hash_table <pointer_hash <tree_node> > htab; - htab.create (37); - - detect_field_duplicates_hash (fieldlist, htab); - htab.dispose (); + hash_table<pointer_hash <tree_node> > htab (37); + detect_field_duplicates_hash (fieldlist, &htab); } } diff --git a/gcc/cfg.c b/gcc/cfg.c index f5af1084d34..6070d9ed220 100644 --- a/gcc/cfg.c +++ b/gcc/cfg.c @@ -1038,11 +1038,11 @@ bb_copy_hasher::equal (const value_type *data, const compare_type *data2) /* Data structures used to maintain mapping between basic blocks and copies. */ -static hash_table <bb_copy_hasher> bb_original; -static hash_table <bb_copy_hasher> bb_copy; +static hash_table<bb_copy_hasher> *bb_original; +static hash_table<bb_copy_hasher> *bb_copy; /* And between loops and copies. */ -static hash_table <bb_copy_hasher> loop_copy; +static hash_table<bb_copy_hasher> *loop_copy; static alloc_pool original_copy_bb_pool; @@ -1055,9 +1055,9 @@ initialize_original_copy_tables (void) original_copy_bb_pool = create_alloc_pool ("original_copy", sizeof (struct htab_bb_copy_original_entry), 10); - bb_original.create (10); - bb_copy.create (10); - loop_copy.create (10); + bb_original = new hash_table<bb_copy_hasher> (10); + bb_copy = new hash_table<bb_copy_hasher> (10); + loop_copy = new hash_table<bb_copy_hasher> (10); } /* Free the data structures to maintain mapping between blocks and @@ -1066,9 +1066,12 @@ void free_original_copy_tables (void) { gcc_assert (original_copy_bb_pool); - bb_copy.dispose (); - bb_original.dispose (); - loop_copy.dispose (); + delete bb_copy; + bb_copy = NULL; + delete bb_original; + bb_copy = NULL; + delete loop_copy; + loop_copy = NULL; free_alloc_pool (original_copy_bb_pool); original_copy_bb_pool = NULL; } @@ -1076,7 +1079,7 @@ free_original_copy_tables (void) /* Removes the value associated with OBJ from table TAB. */ static void -copy_original_table_clear (hash_table <bb_copy_hasher> tab, unsigned obj) +copy_original_table_clear (hash_table<bb_copy_hasher> *tab, unsigned obj) { htab_bb_copy_original_entry **slot; struct htab_bb_copy_original_entry key, *elt; @@ -1085,12 +1088,12 @@ copy_original_table_clear (hash_table <bb_copy_hasher> tab, unsigned obj) return; key.index1 = obj; - slot = tab.find_slot (&key, NO_INSERT); + slot = tab->find_slot (&key, NO_INSERT); if (!slot) return; elt = *slot; - tab.clear_slot (slot); + tab->clear_slot (slot); pool_free (original_copy_bb_pool, elt); } @@ -1098,7 +1101,7 @@ copy_original_table_clear (hash_table <bb_copy_hasher> tab, unsigned obj) Do nothing when data structures are not initialized. */ static void -copy_original_table_set (hash_table <bb_copy_hasher> tab, +copy_original_table_set (hash_table<bb_copy_hasher> *tab, unsigned obj, unsigned val) { struct htab_bb_copy_original_entry **slot; @@ -1108,7 +1111,7 @@ copy_original_table_set (hash_table <bb_copy_hasher> tab, return; key.index1 = obj; - slot = tab.find_slot (&key, INSERT); + slot = tab->find_slot (&key, INSERT); if (!*slot) { *slot = (struct htab_bb_copy_original_entry *) @@ -1136,7 +1139,7 @@ get_bb_original (basic_block bb) gcc_assert (original_copy_bb_pool); key.index1 = bb->index; - entry = bb_original.find (&key); + entry = bb_original->find (&key); if (entry) return BASIC_BLOCK_FOR_FN (cfun, entry->index2); else @@ -1161,7 +1164,7 @@ get_bb_copy (basic_block bb) gcc_assert (original_copy_bb_pool); key.index1 = bb->index; - entry = bb_copy.find (&key); + entry = bb_copy->find (&key); if (entry) return BASIC_BLOCK_FOR_FN (cfun, entry->index2); else @@ -1191,7 +1194,7 @@ get_loop_copy (struct loop *loop) gcc_assert (original_copy_bb_pool); key.index1 = loop->num; - entry = loop_copy.find (&key); + entry = loop_copy->find (&key); if (entry) return get_loop (cfun, entry->index2); else diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c index 70682f1189e..464dec1dd83 100644 --- a/gcc/config/arm/arm.c +++ b/gcc/config/arm/arm.c @@ -4661,25 +4661,25 @@ libcall_hasher::hash (const value_type *p1) return hash_rtx (p1, VOIDmode, NULL, NULL, FALSE); } -typedef hash_table <libcall_hasher> libcall_table_type; +typedef hash_table<libcall_hasher> libcall_table_type; static void -add_libcall (libcall_table_type htab, rtx libcall) +add_libcall (libcall_table_type *htab, rtx libcall) { - *htab.find_slot (libcall, INSERT) = libcall; + *htab->find_slot (libcall, INSERT) = libcall; } static bool arm_libcall_uses_aapcs_base (const_rtx libcall) { static bool init_done = false; - static libcall_table_type libcall_htab; + static libcall_table_type *libcall_htab = NULL; if (!init_done) { init_done = true; - libcall_htab.create (31); + libcall_htab = new libcall_table_type (31); add_libcall (libcall_htab, convert_optab_libfunc (sfloat_optab, SFmode, SImode)); add_libcall (libcall_htab, @@ -4738,7 +4738,7 @@ arm_libcall_uses_aapcs_base (const_rtx libcall) DFmode)); } - return libcall && libcall_htab.find (libcall) != NULL; + return libcall && libcall_htab->find (libcall) != NULL; } static rtx diff --git a/gcc/config/i386/winnt.c b/gcc/config/i386/winnt.c index 10c0b003f8d..dd521331984 100644 --- a/gcc/config/i386/winnt.c +++ b/gcc/config/i386/winnt.c @@ -469,7 +469,7 @@ i386_pe_reloc_rw_mask (void) unsigned int i386_pe_section_type_flags (tree decl, const char *name, int reloc) { - static hash_table <pointer_hash <unsigned int> > htab; + static hash_table<pointer_hash<unsigned int> > *htab = NULL; unsigned int flags; unsigned int **slot; @@ -480,8 +480,8 @@ i386_pe_section_type_flags (tree decl, const char *name, int reloc) /* The names we put in the hashtable will always be the unique versions given to us by the stringtable, so we can just use their addresses as the keys. */ - if (!htab.is_created ()) - htab.create (31); + if (!htab) + htab = new hash_table<pointer_hash<unsigned int> > (31); if (decl && TREE_CODE (decl) == FUNCTION_DECL) flags = SECTION_CODE; @@ -500,7 +500,7 @@ i386_pe_section_type_flags (tree decl, const char *name, int reloc) flags |= SECTION_LINKONCE; /* See if we already have an entry for this section. */ - slot = htab.find_slot ((const unsigned int *)name, INSERT); + slot = htab->find_slot ((const unsigned int *)name, INSERT); if (!*slot) { *slot = (unsigned int *) xmalloc (sizeof (unsigned int)); @@ -771,7 +771,7 @@ static const char * i386_find_on_wrapper_list (const char *target) { static char first_time = 1; - static hash_table <wrapped_symbol_hasher> wrappers; + static hash_table<wrapped_symbol_hasher> *wrappers; if (first_time) { @@ -784,7 +784,7 @@ i386_find_on_wrapper_list (const char *target) char *bufptr; /* Breaks up the char array into separated strings strings and enter them into the hash table. */ - wrappers.create (8); + wrappers = new hash_table_c<wrapped_symbol_hasher> (8); for (bufptr = wrapper_list_buffer; *bufptr; ++bufptr) { char *found = NULL; @@ -797,12 +797,12 @@ i386_find_on_wrapper_list (const char *target) if (*bufptr) *bufptr = 0; if (found) - *wrappers.find_slot (found, INSERT) = found; + *wrappers->find_slot (found, INSERT) = found; } first_time = 0; } - return wrappers.find (target); + return wrappers->find (target); } #endif /* CXX_WRAP_SPEC_LIST */ diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c index de486c6dfac..c2e807c314d 100644 --- a/gcc/config/ia64/ia64.c +++ b/gcc/config/ia64/ia64.c @@ -8586,7 +8586,7 @@ bundle_state_hasher::equal (const value_type *state1, /* Hash table of the bundle states. The key is dfa_state and insn_num of the bundle states. */ -static hash_table <bundle_state_hasher> bundle_state_table; +static hash_table<bundle_state_hasher> *bundle_state_table; /* The function inserts the BUNDLE_STATE into the hash table. The function returns nonzero if the bundle has been inserted into the @@ -8597,7 +8597,7 @@ insert_bundle_state (struct bundle_state *bundle_state) { struct bundle_state **entry_ptr; - entry_ptr = bundle_state_table.find_slot (bundle_state, INSERT); + entry_ptr = bundle_state_table->find_slot (bundle_state, INSERT); if (*entry_ptr == NULL) { bundle_state->next = index_to_bundle_states [bundle_state->insn_num]; @@ -8634,7 +8634,7 @@ insert_bundle_state (struct bundle_state *bundle_state) static void initiate_bundle_state_table (void) { - bundle_state_table.create (50); + bundle_state_table = new hash_table<bundle_state_hasher> (50); } /* Finish work with the hash table. */ @@ -8642,7 +8642,8 @@ initiate_bundle_state_table (void) static void finish_bundle_state_table (void) { - bundle_state_table.dispose (); + delete bundle_state_table; + bundle_state_table = NULL; } diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c index f224ae8d511..b1504ee621e 100644 --- a/gcc/config/mips/mips.c +++ b/gcc/config/mips/mips.c @@ -16018,14 +16018,14 @@ mips_lo_sum_offset_hasher::equal (const value_type *entry, return rtx_equal_p (entry->base, value); } -typedef hash_table <mips_lo_sum_offset_hasher> mips_offset_table; +typedef hash_table<mips_lo_sum_offset_hasher> mips_offset_table; /* Look up symbolic constant X in HTAB, which is a hash table of mips_lo_sum_offsets. If OPTION is NO_INSERT, return true if X can be paired with a recorded LO_SUM, otherwise record X in the table. */ static bool -mips_lo_sum_offset_lookup (mips_offset_table htab, rtx x, +mips_lo_sum_offset_lookup (mips_offset_table *htab, rtx x, enum insert_option option) { rtx base, offset; @@ -16038,7 +16038,7 @@ mips_lo_sum_offset_lookup (mips_offset_table htab, rtx x, base = UNSPEC_ADDRESS (base); /* Look up the base in the hash table. */ - slot = htab.find_slot_with_hash (base, mips_hash_base (base), option); + slot = htab->find_slot_with_hash (base, mips_hash_base (base), option); if (slot == NULL) return false; @@ -16068,7 +16068,7 @@ static int mips_record_lo_sum (rtx *loc, void *data) { if (GET_CODE (*loc) == LO_SUM) - mips_lo_sum_offset_lookup (*(mips_offset_table*) data, + mips_lo_sum_offset_lookup ((mips_offset_table*) data, XEXP (*loc, 1), INSERT); return 0; } @@ -16078,7 +16078,7 @@ mips_record_lo_sum (rtx *loc, void *data) LO_SUMs in the current function. */ static bool -mips_orphaned_high_part_p (mips_offset_table htab, rtx insn) +mips_orphaned_high_part_p (mips_offset_table *htab, rtx insn) { enum mips_symbol_type type; rtx x, set; @@ -16186,7 +16186,6 @@ mips_reorg_process_insns (void) { rtx insn, last_insn, subinsn, next_insn, lo_reg, delayed_reg; int hilo_delay; - mips_offset_table htab; /* Force all instructions to be split into their final form. */ split_all_insns_noflow (); @@ -16227,7 +16226,7 @@ mips_reorg_process_insns (void) if (TARGET_FIX_VR4130 && !ISA_HAS_MACCHI) cfun->machine->all_noreorder_p = false; - htab.create (37); + mips_offset_table htab (37); /* Make a first pass over the instructions, recording all the LO_SUMs. */ for (insn = get_insns (); insn != 0; insn = NEXT_INSN (insn)) @@ -16272,7 +16271,7 @@ mips_reorg_process_insns (void) FOR_EACH_SUBINSN (subinsn, insn) if (INSN_P (subinsn)) { - if (mips_orphaned_high_part_p (htab, subinsn)) + if (mips_orphaned_high_part_p (&htab, subinsn)) { PATTERN (subinsn) = gen_nop (); INSN_CODE (subinsn) = CODE_FOR_nop; @@ -16286,7 +16285,7 @@ mips_reorg_process_insns (void) { /* INSN is a single instruction. Delete it if it's an orphaned high-part relocation. */ - if (mips_orphaned_high_part_p (htab, insn)) + if (mips_orphaned_high_part_p (&htab, insn)) delete_insn (insn); /* Also delete cache barriers if the last instruction was an annulled branch. INSN will not be speculatively @@ -16305,8 +16304,6 @@ mips_reorg_process_insns (void) } } } - - htab.dispose (); } /* Return true if the function has a long branch instruction. */ diff --git a/gcc/config/sol2.c b/gcc/config/sol2.c index d07a9411faf..c7764b1993d 100644 --- a/gcc/config/sol2.c +++ b/gcc/config/sol2.c @@ -195,7 +195,7 @@ comdat_entry_hasher::equal (const value_type *entry1, /* Hash table of group signature symbols. */ -static hash_table <comdat_entry_hasher> solaris_comdat_htab; +static hash_table<comdat_entry_hasher> *solaris_comdat_htab; /* Output assembly to switch to COMDAT group section NAME with attributes FLAGS and group signature symbol DECL, using Sun as syntax. */ @@ -236,11 +236,11 @@ solaris_elf_asm_comdat_section (const char *name, unsigned int flags, tree decl) identify the missing ones without changing the affected frontents, remember the signature symbols and emit those not marked TREE_SYMBOL_REFERENCED in solaris_file_end. */ - if (!solaris_comdat_htab.is_created ()) - solaris_comdat_htab.create (37); + if (!solaris_comdat_htab) + solaris_comdat_htab = new hash_table<comdat_entry_hasher> (37); entry.sig = signature; - slot = solaris_comdat_htab.find_slot (&entry, INSERT); + slot = solaris_comdat_htab->find_slot (&entry, INSERT); if (*slot == NULL) { @@ -284,10 +284,11 @@ solaris_define_comdat_signature (comdat_entry **slot, void solaris_file_end (void) { - if (!solaris_comdat_htab.is_created ()) + if (!solaris_comdat_htab) return; - solaris_comdat_htab.traverse <void *, solaris_define_comdat_signature> (NULL); + solaris_comdat_htab->traverse <void *, solaris_define_comdat_signature> + (NULL); } void diff --git a/gcc/coverage.c b/gcc/coverage.c index 44b616c7872..0eeaaa519ec 100644 --- a/gcc/coverage.c +++ b/gcc/coverage.c @@ -174,7 +174,7 @@ counts_entry::remove (value_type *entry) } /* Hash table of count data. */ -static hash_table <counts_entry> counts_hash; +static hash_table<counts_entry> *counts_hash; /* Read in the counts file, if available. */ @@ -215,7 +215,7 @@ read_counts_file (void) tag = gcov_read_unsigned (); bbg_file_stamp = crc32_unsigned (bbg_file_stamp, tag); - counts_hash.create (10); + counts_hash = new hash_table<counts_entry> (10); while ((tag = gcov_read_unsigned ())) { gcov_unsigned_t length; @@ -270,7 +270,7 @@ read_counts_file (void) elt.ident = fn_ident; elt.ctr = GCOV_COUNTER_FOR_TAG (tag); - slot = counts_hash.find_slot (&elt, INSERT); + slot = counts_hash->find_slot (&elt, INSERT); entry = *slot; if (!entry) { @@ -291,14 +291,16 @@ read_counts_file (void) error ("checksum is (%x,%x) instead of (%x,%x)", entry->lineno_checksum, entry->cfg_checksum, lineno_checksum, cfg_checksum); - counts_hash.dispose (); + delete counts_hash; + counts_hash = NULL; break; } else if (entry->summary.num != n_counts) { error ("Profile data for function %u is corrupted", fn_ident); error ("number of counters is %d instead of %d", entry->summary.num, n_counts); - counts_hash.dispose (); + delete counts_hash; + counts_hash = NULL; break; } else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE) @@ -324,7 +326,8 @@ read_counts_file (void) { error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted", da_file_name); - counts_hash.dispose (); + delete counts_hash; + counts_hash = NULL; break; } } @@ -342,7 +345,7 @@ get_coverage_counts (unsigned counter, unsigned expected, counts_entry_t *entry, elt; /* No hash table, no counts. */ - if (!counts_hash.is_created ()) + if (!counts_hash) { static int warned = 0; @@ -358,7 +361,7 @@ get_coverage_counts (unsigned counter, unsigned expected, elt.ident = current_function_funcdef_no + 1; elt.ctr = counter; - entry = counts_hash.find (&elt); + entry = counts_hash->find (&elt); if (!entry || !entry->summary.num) /* The function was not emitted, or is weak and not chosen in the final executable. Silently fail, because there's nothing we diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 170b90b7c75..f2f4e3cb5f0 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,8 @@ +2014-06-24 Trevor Saunders <tsaunders@mozilla.com> + + * class.c, semantics.c, tree.c, vtable-class-hierarchy.c: + Adjust. + 2014-06-24 Jakub Jelinek <jakub@redhat.com> * parser.c (cp_parser_omp_for_loop): For diff --git a/gcc/cp/class.c b/gcc/cp/class.c index a96b3602786..1a7529e806c 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -6709,7 +6709,7 @@ finish_struct (tree t, tree attributes) } /* Hash table to avoid endless recursion when handling references. */ -static hash_table <pointer_hash <tree_node> > fixed_type_or_null_ref_ht; +static hash_table<pointer_hash<tree_node> > *fixed_type_or_null_ref_ht; /* Return the dynamic type of INSTANCE, if known. Used to determine whether the virtual function table is needed @@ -6826,8 +6826,9 @@ fixed_type_or_null (tree instance, int *nonnull, int *cdtorp) else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE) { /* We only need one hash table because it is always left empty. */ - if (!fixed_type_or_null_ref_ht.is_created ()) - fixed_type_or_null_ref_ht.create (37); + if (!fixed_type_or_null_ref_ht) + fixed_type_or_null_ref_ht + = new hash_table<pointer_hash<tree_node> > (37); /* Reference variables should be references to objects. */ if (nonnull) @@ -6839,15 +6840,15 @@ fixed_type_or_null (tree instance, int *nonnull, int *cdtorp) if (VAR_P (instance) && DECL_INITIAL (instance) && !type_dependent_expression_p_push (DECL_INITIAL (instance)) - && !fixed_type_or_null_ref_ht.find (instance)) + && !fixed_type_or_null_ref_ht->find (instance)) { tree type; tree_node **slot; - slot = fixed_type_or_null_ref_ht.find_slot (instance, INSERT); + slot = fixed_type_or_null_ref_ht->find_slot (instance, INSERT); *slot = instance; type = RECUR (DECL_INITIAL (instance)); - fixed_type_or_null_ref_ht.remove_elt (instance); + fixed_type_or_null_ref_ht->remove_elt (instance); return type; } diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index ec510c96fed..aad6e2f4cb2 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -4049,9 +4049,11 @@ expand_or_defer_fn (tree fn) struct nrv_data { + nrv_data () : visited (37) {} + tree var; tree result; - hash_table <pointer_hash <tree_node> > visited; + hash_table<pointer_hash <tree_node> > visited; }; /* Helper function for walk_tree, used by finalize_nrv below. */ @@ -4131,9 +4133,7 @@ finalize_nrv (tree *tp, tree var, tree result) data.var = var; data.result = result; - data.visited.create (37); cp_walk_tree (tp, finalize_nrv_r, &data, 0); - data.visited.dispose (); } /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */ diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index 36166052d08..7ff593564ca 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -2092,8 +2092,8 @@ static tree verify_stmt_tree_r (tree* tp, int * /*walk_subtrees*/, void* data) { tree t = *tp; - hash_table <pointer_hash <tree_node> > *statements - = static_cast <hash_table <pointer_hash <tree_node> > *> (data); + hash_table<pointer_hash <tree_node> > *statements + = static_cast <hash_table<pointer_hash <tree_node> > *> (data); tree_node **slot; if (!STATEMENT_CODE_P (TREE_CODE (t))) @@ -2116,10 +2116,8 @@ verify_stmt_tree_r (tree* tp, int * /*walk_subtrees*/, void* data) void verify_stmt_tree (tree t) { - hash_table <pointer_hash <tree_node> > statements; - statements.create (37); + hash_table<pointer_hash <tree_node> > statements (37); cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL); - statements.dispose (); } /* Check if the type T depends on a type with no linkage and if so, return diff --git a/gcc/cp/vtable-class-hierarchy.c b/gcc/cp/vtable-class-hierarchy.c index b481273ae85..f69e6bb3c95 100644 --- a/gcc/cp/vtable-class-hierarchy.c +++ b/gcc/cp/vtable-class-hierarchy.c @@ -1028,7 +1028,7 @@ register_all_pairs (tree body) if (vtbl_ptr_array->length() > 0 || (current->is_used - || (current->registered.size() > 0))) + || (current->registered->size() > 0))) { insert_call_to_register_pair (vtbl_ptr_array, arg1, arg2, size_hint_arg, str1, @@ -1114,7 +1114,7 @@ write_out_vtv_count_data (void) { struct vtbl_map_node *current = vtbl_map_nodes_vec[i]; if (!current->is_used - && current->registered.size() == 0) + && current->registered->size() == 0) unused_vtbl_map_vars++; } diff --git a/gcc/cselib.c b/gcc/cselib.c index 00a04baab6e..d069f1095dd 100644 --- a/gcc/cselib.c +++ b/gcc/cselib.c @@ -145,10 +145,10 @@ cselib_hasher::equal (const value_type *v, const compare_type *x_arg) } /* A table that enables us to look up elts by their value. */ -static hash_table <cselib_hasher> cselib_hash_table; +static hash_table<cselib_hasher> *cselib_hash_table; /* A table to hold preserved values. */ -static hash_table <cselib_hasher> cselib_preserved_hash_table; +static hash_table<cselib_hasher> *cselib_preserved_hash_table; /* This is a global so we don't have to pass this through every function. It is used in new_elt_loc_list to set SETTING_INSN. */ @@ -499,13 +499,13 @@ preserve_constants_and_equivs (cselib_val **x, void *info ATTRIBUTE_UNUSED) GET_MODE (v->val_rtx), v->val_rtx, VOIDmode }; cselib_val **slot - = cselib_preserved_hash_table.find_slot_with_hash (&lookup, + = cselib_preserved_hash_table->find_slot_with_hash (&lookup, v->hash, INSERT); gcc_assert (!*slot); *slot = v; } - cselib_hash_table.clear_slot (x); + cselib_hash_table->clear_slot (x); return 1; } @@ -546,10 +546,11 @@ cselib_reset_table (unsigned int num) } if (cselib_preserve_constants) - cselib_hash_table.traverse <void *, preserve_constants_and_equivs> (NULL); + cselib_hash_table->traverse <void *, preserve_constants_and_equivs> + (NULL); else { - cselib_hash_table.empty (); + cselib_hash_table->empty (); gcc_checking_assert (!cselib_any_perm_equivs); } @@ -581,10 +582,10 @@ cselib_find_slot (enum machine_mode mode, rtx x, hashval_t hash, cselib_val **slot = NULL; cselib_hasher::compare_type lookup = { mode, x, memmode }; if (cselib_preserve_constants) - slot = cselib_preserved_hash_table.find_slot_with_hash (&lookup, hash, - NO_INSERT); + slot = cselib_preserved_hash_table->find_slot_with_hash (&lookup, hash, + NO_INSERT); if (!slot) - slot = cselib_hash_table.find_slot_with_hash (&lookup, hash, insert); + slot = cselib_hash_table->find_slot_with_hash (&lookup, hash, insert); return slot; } @@ -662,7 +663,7 @@ discard_useless_values (cselib_val **x, void *info ATTRIBUTE_UNUSED) cselib_discard_hook (v); CSELIB_VAL_PTR (v->val_rtx) = NULL; - cselib_hash_table.clear_slot (x); + cselib_hash_table->clear_slot (x); unchain_one_value (v); n_useless_values--; } @@ -683,7 +684,7 @@ remove_useless_values (void) do { values_became_useless = 0; - cselib_hash_table.traverse <void *, discard_useless_locs> (NULL); + cselib_hash_table->traverse <void *, discard_useless_locs> (NULL); } while (values_became_useless); @@ -702,7 +703,7 @@ remove_useless_values (void) n_debug_values -= n_useless_debug_values; n_useless_debug_values = 0; - cselib_hash_table.traverse <void *, discard_useless_values> (NULL); + cselib_hash_table->traverse <void *, discard_useless_values> (NULL); gcc_assert (!n_useless_values); } @@ -2703,7 +2704,7 @@ cselib_process_insn (rtx insn) quadratic behavior for very large hashtables with very few useless elements. */ && ((unsigned int)n_useless_values - > (cselib_hash_table.elements () - n_debug_values) / 4)) + > (cselib_hash_table->elements () - n_debug_values) / 4)) remove_useless_values (); } @@ -2744,9 +2745,9 @@ cselib_init (int record_what) } used_regs = XNEWVEC (unsigned int, cselib_nregs); n_used_regs = 0; - cselib_hash_table.create (31); + cselib_hash_table = new hash_table<cselib_hasher> (31); if (cselib_preserve_constants) - cselib_preserved_hash_table.create (31); + cselib_preserved_hash_table = new hash_table<cselib_hasher> (31); next_uid = 1; } @@ -2766,9 +2767,11 @@ cselib_finish (void) free_alloc_pool (cselib_val_pool); free_alloc_pool (value_pool); cselib_clear_table (); - cselib_hash_table.dispose (); + delete cselib_hash_table; + cselib_hash_table = NULL; if (preserved) - cselib_preserved_hash_table.dispose (); + delete cselib_preserved_hash_table; + cselib_preserved_hash_table = NULL; free (used_regs); used_regs = 0; n_useless_values = 0; @@ -2857,9 +2860,9 @@ void dump_cselib_table (FILE *out) { fprintf (out, "cselib hash table:\n"); - cselib_hash_table.traverse <FILE *, dump_cselib_val> (out); + cselib_hash_table->traverse <FILE *, dump_cselib_val> (out); fprintf (out, "cselib preserved hash table:\n"); - cselib_preserved_hash_table.traverse <FILE *, dump_cselib_val> (out); + cselib_preserved_hash_table->traverse <FILE *, dump_cselib_val> (out); if (first_containing_mem != &dummy_val) { fputs ("first mem ", out); diff --git a/gcc/data-streamer-out.c b/gcc/data-streamer-out.c index 3fe9d457aa3..8eefd2f855e 100644 --- a/gcc/data-streamer-out.c +++ b/gcc/data-streamer-out.c @@ -49,7 +49,7 @@ streamer_string_index (struct output_block *ob, const char *s, unsigned int len, s_slot.len = len; s_slot.slot_num = 0; - slot = ob->string_hash_table.find_slot (&s_slot, INSERT); + slot = ob->string_hash_table->find_slot (&s_slot, INSERT); if (*slot == NULL) { struct lto_output_stream *string_stream = ob->string_stream; diff --git a/gcc/dse.c b/gcc/dse.c index 167920cf098..d5b2a14b618 100644 --- a/gcc/dse.c +++ b/gcc/dse.c @@ -658,7 +658,7 @@ invariant_group_base_hasher::hash (const value_type *gi) } /* Tables of group_info structures, hashed by base value. */ -static hash_table <invariant_group_base_hasher> rtx_group_table; +static hash_table<invariant_group_base_hasher> *rtx_group_table; /* Get the GROUP for BASE. Add a new group if it is not there. */ @@ -675,7 +675,7 @@ get_group_info (rtx base) /* Find the store_base_info structure for BASE, creating a new one if necessary. */ tmp_gi.rtx_base = base; - slot = rtx_group_table.find_slot (&tmp_gi, INSERT); + slot = rtx_group_table->find_slot (&tmp_gi, INSERT); gi = (group_info_t) *slot; } else @@ -765,7 +765,7 @@ dse_step0 (void) = create_alloc_pool ("deferred_change_pool", sizeof (struct deferred_change), 10); - rtx_group_table.create (11); + rtx_group_table = new hash_table<invariant_group_base_hasher> (11); bb_table = XNEWVEC (bb_info_t, last_basic_block_for_fn (cfun)); rtx_group_next_id = 0; @@ -2829,7 +2829,7 @@ dse_step1 (void) BITMAP_FREE (regs_live); cselib_finish (); - rtx_group_table.empty (); + rtx_group_table->empty (); } @@ -3654,7 +3654,8 @@ dse_step7 (void) end_alias_analysis (); free (bb_table); - rtx_group_table.dispose (); + delete rtx_group_table; + rtx_group_table = NULL; rtx_group_vec.release (); BITMAP_FREE (all_blocks); BITMAP_FREE (scratch); diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c index 47fd0287a67..386b0f7185c 100644 --- a/gcc/dwarf2cfi.c +++ b/gcc/dwarf2cfi.c @@ -182,7 +182,7 @@ trace_info_hasher::equal (const value_type *a, const compare_type *b) /* The variables making up the pseudo-cfg, as described above. */ static vec<dw_trace_info> trace_info; static vec<dw_trace_info_ref> trace_work_list; -static hash_table <trace_info_hasher> trace_index; +static hash_table<trace_info_hasher> *trace_index; /* A vector of call frame insns for the CIE. */ cfi_vec cie_cfi_vec; @@ -307,7 +307,7 @@ get_trace_info (rtx insn) { dw_trace_info dummy; dummy.head = insn; - return trace_index.find_with_hash (&dummy, INSN_UID (insn)); + return trace_index->find_with_hash (&dummy, INSN_UID (insn)); } static bool @@ -2774,7 +2774,8 @@ create_pseudo_cfg (void) /* Create the trace index after we've finished building trace_info, avoiding stale pointer problems due to reallocation. */ - trace_index.create (trace_info.length ()); + trace_index + = new hash_table<trace_info_hasher> (trace_info.length ()); dw_trace_info *tp; FOR_EACH_VEC_ELT (trace_info, i, tp) { @@ -2785,7 +2786,7 @@ create_pseudo_cfg (void) rtx_name[(int) GET_CODE (tp->head)], INSN_UID (tp->head), tp->switch_sections ? " (section switch)" : ""); - slot = trace_index.find_slot_with_hash (tp, INSN_UID (tp->head), INSERT); + slot = trace_index->find_slot_with_hash (tp, INSN_UID (tp->head), INSERT); gcc_assert (*slot == NULL); *slot = tp; } @@ -2936,7 +2937,8 @@ execute_dwarf2_frame (void) } trace_info.release (); - trace_index.dispose (); + delete trace_index; + trace_index = NULL; return 0; } diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index 933ec62c3db..f69253684e5 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -6745,21 +6745,21 @@ cu_hash_table_entry_hasher::remove (value_type *entry) } } -typedef hash_table <cu_hash_table_entry_hasher> cu_hash_type; +typedef hash_table<cu_hash_table_entry_hasher> cu_hash_type; /* Check whether we have already seen this CU and set up SYM_NUM accordingly. */ static int -check_duplicate_cu (dw_die_ref cu, cu_hash_type htable, unsigned int *sym_num) +check_duplicate_cu (dw_die_ref cu, cu_hash_type *htable, unsigned int *sym_num) { struct cu_hash_table_entry dummy; struct cu_hash_table_entry **slot, *entry, *last = &dummy; dummy.max_comdat_num = 0; - slot = htable.find_slot_with_hash (cu, - htab_hash_string (cu->die_id.die_symbol), - INSERT); + slot = htable->find_slot_with_hash (cu, + htab_hash_string (cu->die_id.die_symbol), + INSERT); entry = *slot; for (; entry; last = entry, entry = entry->next) @@ -6785,14 +6785,14 @@ check_duplicate_cu (dw_die_ref cu, cu_hash_type htable, unsigned int *sym_num) /* Record SYM_NUM to record of CU in HTABLE. */ static void -record_comdat_symbol_number (dw_die_ref cu, cu_hash_type htable, +record_comdat_symbol_number (dw_die_ref cu, cu_hash_type *htable, unsigned int sym_num) { struct cu_hash_table_entry **slot, *entry; - slot = htable.find_slot_with_hash (cu, - htab_hash_string (cu->die_id.die_symbol), - NO_INSERT); + slot = htable->find_slot_with_hash (cu, + htab_hash_string (cu->die_id.die_symbol), + NO_INSERT); entry = *slot; entry->max_comdat_num = sym_num; @@ -6808,7 +6808,6 @@ break_out_includes (dw_die_ref die) dw_die_ref c; dw_die_ref unit = NULL; limbo_die_node *node, **pnode; - cu_hash_type cu_hash_table; c = die->die_child; if (c) do { @@ -6841,7 +6840,7 @@ break_out_includes (dw_die_ref die) #endif assign_symbol_names (die); - cu_hash_table.create (10); + cu_hash_type cu_hash_table (10); for (node = limbo_die_list, pnode = &limbo_die_list; node; node = node->next) @@ -6849,7 +6848,7 @@ break_out_includes (dw_die_ref die) int is_dupl; compute_section_prefix (node->die); - is_dupl = check_duplicate_cu (node->die, cu_hash_table, + is_dupl = check_duplicate_cu (node->die, &cu_hash_table, &comdat_symbol_number); assign_symbol_names (node->die); if (is_dupl) @@ -6857,11 +6856,10 @@ break_out_includes (dw_die_ref die) else { pnode = &node->next; - record_comdat_symbol_number (node->die, cu_hash_table, + record_comdat_symbol_number (node->die, &cu_hash_table, comdat_symbol_number); } } - cu_hash_table.dispose (); } /* Return non-zero if this DIE is a declaration. */ @@ -7070,7 +7068,7 @@ decl_table_entry_hasher::equal (const value_type *entry1, return entry1->orig == entry2; } -typedef hash_table <decl_table_entry_hasher> decl_hash_type; +typedef hash_table<decl_table_entry_hasher> decl_hash_type; /* Copy DIE and its ancestors, up to, but not including, the compile unit or type unit entry, to a new tree. Adds the new tree to UNIT and returns @@ -7078,7 +7076,8 @@ typedef hash_table <decl_table_entry_hasher> decl_hash_type; to check if the ancestor has already been copied into UNIT. */ static dw_die_ref -copy_ancestor_tree (dw_die_ref unit, dw_die_ref die, decl_hash_type decl_table) +copy_ancestor_tree (dw_die_ref unit, dw_die_ref die, + decl_hash_type *decl_table) { dw_die_ref parent = die->die_parent; dw_die_ref new_parent = unit; @@ -7086,11 +7085,11 @@ copy_ancestor_tree (dw_die_ref unit, dw_die_ref die, decl_hash_type decl_table) decl_table_entry **slot = NULL; struct decl_table_entry *entry = NULL; - if (decl_table.is_created ()) + if (decl_table) { /* Check if the entry has already been copied to UNIT. */ - slot = decl_table.find_slot_with_hash (die, htab_hash_pointer (die), - INSERT); + slot = decl_table->find_slot_with_hash (die, htab_hash_pointer (die), + INSERT); if (*slot != HTAB_EMPTY_ENTRY) { entry = *slot; @@ -7116,7 +7115,7 @@ copy_ancestor_tree (dw_die_ref unit, dw_die_ref die, decl_hash_type decl_table) copy = clone_as_declaration (die); add_child_die (new_parent, copy); - if (decl_table.is_created ()) + if (decl_table) { /* Record the pointer to the copy. */ entry->copy = copy; @@ -7171,7 +7170,7 @@ copy_declaration_context (dw_die_ref unit, dw_die_ref die) if (decl->die_parent != NULL && !is_unit_die (decl->die_parent)) { - new_decl = copy_ancestor_tree (unit, decl, decl_hash_type ()); + new_decl = copy_ancestor_tree (unit, decl, NULL); if (new_decl != NULL) { remove_AT (new_decl, DW_AT_signature); @@ -7396,7 +7395,7 @@ break_out_comdat_types (dw_die_ref die) Enter all the cloned children into the hash table decl_table. */ static dw_die_ref -clone_tree_partial (dw_die_ref die, decl_hash_type decl_table) +clone_tree_partial (dw_die_ref die, decl_hash_type *decl_table) { dw_die_ref c; dw_die_ref clone; @@ -7408,8 +7407,8 @@ clone_tree_partial (dw_die_ref die, decl_hash_type decl_table) else clone = clone_die (die); - slot = decl_table.find_slot_with_hash (die, - htab_hash_pointer (die), INSERT); + slot = decl_table->find_slot_with_hash (die, + htab_hash_pointer (die), INSERT); /* Assert that DIE isn't in the hash table yet. If it would be there before, the ancestors would be necessarily there as well, therefore @@ -7433,7 +7432,7 @@ clone_tree_partial (dw_die_ref die, decl_hash_type decl_table) type_unit). */ static void -copy_decls_walk (dw_die_ref unit, dw_die_ref die, decl_hash_type decl_table) +copy_decls_walk (dw_die_ref unit, dw_die_ref die, decl_hash_type *decl_table) { dw_die_ref c; dw_attr_ref a; @@ -7450,8 +7449,9 @@ copy_decls_walk (dw_die_ref unit, dw_die_ref die, decl_hash_type decl_table) if (targ->die_mark != 0 || targ->comdat_type_p) continue; - slot = decl_table.find_slot_with_hash (targ, htab_hash_pointer (targ), - INSERT); + slot = decl_table->find_slot_with_hash (targ, + htab_hash_pointer (targ), + INSERT); if (*slot != HTAB_EMPTY_ENTRY) { @@ -7530,12 +7530,9 @@ copy_decls_walk (dw_die_ref unit, dw_die_ref die, decl_hash_type decl_table) static void copy_decls_for_unworthy_types (dw_die_ref unit) { - decl_hash_type decl_table; - mark_dies (unit); - decl_table.create (10); - copy_decls_walk (unit, unit, decl_table); - decl_table.dispose (); + decl_hash_type decl_table (10); + copy_decls_walk (unit, unit, &decl_table); unmark_dies (unit); } @@ -7627,18 +7624,18 @@ external_ref_hasher::equal (const value_type *r1, const compare_type *r2) return r1->type == r2->type; } -typedef hash_table <external_ref_hasher> external_ref_hash_type; +typedef hash_table<external_ref_hasher> external_ref_hash_type; /* Return a pointer to the external_ref for references to DIE. */ static struct external_ref * -lookup_external_ref (external_ref_hash_type map, dw_die_ref die) +lookup_external_ref (external_ref_hash_type *map, dw_die_ref die) { struct external_ref ref, *ref_p; external_ref **slot; ref.type = die; - slot = map.find_slot (&ref, INSERT); + slot = map->find_slot (&ref, INSERT); if (*slot != HTAB_EMPTY_ENTRY) return *slot; @@ -7654,7 +7651,7 @@ lookup_external_ref (external_ref_hash_type map, dw_die_ref die) references, remember how many we've seen. */ static void -optimize_external_refs_1 (dw_die_ref die, external_ref_hash_type map) +optimize_external_refs_1 (dw_die_ref die, external_ref_hash_type *map) { dw_die_ref c; dw_attr_ref a; @@ -7725,13 +7722,12 @@ dwarf2_build_local_stub (external_ref **slot, dw_die_ref data) them which will be applied in build_abbrev_table. This is useful because references to local DIEs are smaller. */ -static external_ref_hash_type +static external_ref_hash_type * optimize_external_refs (dw_die_ref die) { - external_ref_hash_type map; - map.create (10); + external_ref_hash_type *map = new external_ref_hash_type (10); optimize_external_refs_1 (die, map); - map.traverse <dw_die_ref, dwarf2_build_local_stub> (die); + map->traverse <dw_die_ref, dwarf2_build_local_stub> (die); return map; } @@ -7741,7 +7737,7 @@ optimize_external_refs (dw_die_ref die) die are visited recursively. */ static void -build_abbrev_table (dw_die_ref die, external_ref_hash_type extern_map) +build_abbrev_table (dw_die_ref die, external_ref_hash_type *extern_map) { unsigned long abbrev_id; unsigned int n_alloc; @@ -8950,7 +8946,6 @@ output_comp_unit (dw_die_ref die, int output_if_empty) { const char *secname, *oldsym; char *tmp; - external_ref_hash_type extern_map; /* Unless we are outputting main CU, we may throw away empty ones. */ if (!output_if_empty && die->die_child == NULL) @@ -8963,11 +8958,11 @@ output_comp_unit (dw_die_ref die, int output_if_empty) this CU so we know which get local refs. */ mark_dies (die); - extern_map = optimize_external_refs (die); + external_ref_hash_type *extern_map = optimize_external_refs (die); build_abbrev_table (die, extern_map); - extern_map.dispose (); + delete extern_map; /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE; @@ -9142,16 +9137,16 @@ output_comdat_type_unit (comdat_type_node *node) #if defined (OBJECT_FORMAT_ELF) tree comdat_key; #endif - external_ref_hash_type extern_map; /* First mark all the DIEs in this CU so we know which get local refs. */ mark_dies (node->root_die); - extern_map = optimize_external_refs (node->root_die); + external_ref_hash_type *extern_map = optimize_external_refs (node->root_die); build_abbrev_table (node->root_die, extern_map); - extern_map.dispose (); + delete extern_map; + extern_map = NULL; /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE; @@ -21892,7 +21887,7 @@ macinfo_entry_hasher::equal (const value_type *entry1, return !strcmp (entry1->info, entry2->info); } -typedef hash_table <macinfo_entry_hasher> macinfo_hash_type; +typedef hash_table<macinfo_entry_hasher> macinfo_hash_type; /* Output a single .debug_macinfo entry. */ @@ -21982,7 +21977,7 @@ output_macinfo_op (macinfo_entry *ref) static unsigned optimize_macinfo_range (unsigned int idx, vec<macinfo_entry, va_gc> *files, - macinfo_hash_type *macinfo_htab) + macinfo_hash_type **macinfo_htab) { macinfo_entry *first, *second, *cur, *inc; char linebuf[sizeof (HOST_WIDE_INT) * 3 + 1]; @@ -22069,10 +22064,10 @@ optimize_macinfo_range (unsigned int idx, vec<macinfo_entry, va_gc> *files, inc->code = DW_MACRO_GNU_transparent_include; inc->lineno = 0; inc->info = ggc_strdup (grp_name); - if (!macinfo_htab->is_created ()) - macinfo_htab->create (10); + if (!*macinfo_htab) + *macinfo_htab = new macinfo_hash_type (10); /* Avoid emitting duplicates. */ - slot = macinfo_htab->find_slot (inc, INSERT); + slot = (*macinfo_htab)->find_slot (inc, INSERT); if (*slot != NULL) { inc->code = 0; @@ -22092,7 +22087,7 @@ optimize_macinfo_range (unsigned int idx, vec<macinfo_entry, va_gc> *files, else { *slot = inc; - inc->lineno = macinfo_htab->elements (); + inc->lineno = (*macinfo_htab)->elements (); output_macinfo_op (inc); } return count; @@ -22143,7 +22138,7 @@ output_macinfo (void) unsigned long length = vec_safe_length (macinfo_table); macinfo_entry *ref; vec<macinfo_entry, va_gc> *files = NULL; - macinfo_hash_type macinfo_htab; + macinfo_hash_type *macinfo_htab = NULL; if (! length) return; @@ -22216,10 +22211,11 @@ output_macinfo (void) ref->code = 0; } - if (!macinfo_htab.is_created ()) + if (!macinfo_htab) return; - macinfo_htab.dispose (); + delete macinfo_htab; + macinfo_htab = NULL; /* If any DW_MACRO_GNU_transparent_include were used, on those DW_MACRO_GNU_transparent_include entries terminate the @@ -24081,14 +24077,14 @@ loc_list_hasher::equal (const value_type *a, const compare_type *b) return a == NULL && b == NULL; } -typedef hash_table <loc_list_hasher> loc_list_hash_type; +typedef hash_table<loc_list_hasher> loc_list_hash_type; /* Recursively optimize location lists referenced from DIE children and share them whenever possible. */ static void -optimize_location_lists_1 (dw_die_ref die, loc_list_hash_type htab) +optimize_location_lists_1 (dw_die_ref die, loc_list_hash_type *htab) { dw_die_ref c; dw_attr_ref a; @@ -24102,7 +24098,7 @@ optimize_location_lists_1 (dw_die_ref die, loc_list_hash_type htab) /* TODO: perform some optimizations here, before hashing it and storing into the hash table. */ hash_loc_list (list); - slot = htab.find_slot_with_hash (list, list->hash, INSERT); + slot = htab->find_slot_with_hash (list, list->hash, INSERT); if (*slot == NULL) *slot = list; else @@ -24151,10 +24147,8 @@ index_location_lists (dw_die_ref die) static void optimize_location_lists (dw_die_ref die) { - loc_list_hash_type htab; - htab.create (500); - optimize_location_lists_1 (die, htab); - htab.dispose (); + loc_list_hash_type htab (500); + optimize_location_lists_1 (die, &htab); } /* Output stuff that dwarf requires at the end of every file, @@ -24165,7 +24159,6 @@ dwarf2out_finish (const char *filename) { limbo_die_node *node, *next_node; comdat_type_node *ctnode; - hash_table <comdat_type_hasher> comdat_type_table; unsigned int i; dw_die_ref main_comp_unit_die; @@ -24434,7 +24427,7 @@ dwarf2out_finish (const char *filename) for (node = limbo_die_list; node; node = node->next) output_comp_unit (node->die, 0); - comdat_type_table.create (100); + hash_table<comdat_type_hasher> comdat_type_table (100); for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next) { comdat_type_node **slot = comdat_type_table.find_slot (ctnode, INSERT); @@ -24455,7 +24448,6 @@ dwarf2out_finish (const char *filename) output_comdat_type_unit (ctnode); *slot = ctnode; } - comdat_type_table.dispose (); /* The AT_pubnames attribute needs to go in all skeleton dies, including both the main_cu and all skeleton TUs. Making this call unconditional diff --git a/gcc/except.c b/gcc/except.c index 018439e9e10..dc5c1d20132 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -209,7 +209,7 @@ action_record_hasher::equal (const value_type *entry, const compare_type *data) return entry->filter == data->filter && entry->next == data->next; } -typedef hash_table <action_record_hasher> action_hash_type; +typedef hash_table<action_record_hasher> action_hash_type; static bool get_eh_region_and_lp_from_rtx (const_rtx, eh_region *, eh_landing_pad *); @@ -219,7 +219,7 @@ static hashval_t t2r_hash (const void *); static void dw2_build_landing_pads (void); -static int collect_one_action_chain (action_hash_type, eh_region); +static int collect_one_action_chain (action_hash_type *, eh_region); static int add_call_site (rtx, int, int); static void push_uleb128 (vec<uchar, va_gc> **, unsigned int); @@ -760,7 +760,7 @@ ttypes_filter_hasher::hash (const value_type *entry) return TREE_HASH (entry->t); } -typedef hash_table <ttypes_filter_hasher> ttypes_hash_type; +typedef hash_table<ttypes_filter_hasher> ttypes_hash_type; /* Helper for ehspec hashing. */ @@ -797,18 +797,18 @@ ehspec_hasher::hash (const value_type *entry) return h; } -typedef hash_table <ehspec_hasher> ehspec_hash_type; +typedef hash_table<ehspec_hasher> ehspec_hash_type; /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH to speed up the search. Return the filter value to be used. */ static int -add_ttypes_entry (ttypes_hash_type ttypes_hash, tree type) +add_ttypes_entry (ttypes_hash_type *ttypes_hash, tree type) { struct ttypes_filter **slot, *n; - slot = ttypes_hash.find_slot_with_hash (type, (hashval_t) TREE_HASH (type), + slot = ttypes_hash->find_slot_with_hash (type, (hashval_t) TREE_HASH (type), INSERT); if ((n = *slot) == NULL) @@ -830,14 +830,14 @@ add_ttypes_entry (ttypes_hash_type ttypes_hash, tree type) to speed up the search. Return the filter value to be used. */ static int -add_ehspec_entry (ehspec_hash_type ehspec_hash, ttypes_hash_type ttypes_hash, +add_ehspec_entry (ehspec_hash_type *ehspec_hash, ttypes_hash_type *ttypes_hash, tree list) { struct ttypes_filter **slot, *n; struct ttypes_filter dummy; dummy.t = list; - slot = ehspec_hash.find_slot (&dummy, INSERT); + slot = ehspec_hash->find_slot (&dummy, INSERT); if ((n = *slot) == NULL) { @@ -886,8 +886,6 @@ void assign_filter_values (void) { int i; - ttypes_hash_type ttypes; - ehspec_hash_type ehspec; eh_region r; eh_catch c; @@ -897,8 +895,8 @@ assign_filter_values (void) else vec_alloc (cfun->eh->ehspec_data.other, 64); - ttypes.create (31); - ehspec.create (31); + ehspec_hash_type ehspec (31); + ttypes_hash_type ttypes (31); for (i = 1; vec_safe_iterate (cfun->eh->region_array, i, &r); ++i) { @@ -922,7 +920,8 @@ assign_filter_values (void) for ( ; tp_node; tp_node = TREE_CHAIN (tp_node)) { - int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node)); + int flt + = add_ttypes_entry (&ttypes, TREE_VALUE (tp_node)); tree flt_node = build_int_cst (integer_type_node, flt); c->filter_list @@ -933,7 +932,7 @@ assign_filter_values (void) { /* Get a filter value for the NULL list also since it will need an action record anyway. */ - int flt = add_ttypes_entry (ttypes, NULL); + int flt = add_ttypes_entry (&ttypes, NULL); tree flt_node = build_int_cst (integer_type_node, flt); c->filter_list @@ -944,16 +943,13 @@ assign_filter_values (void) case ERT_ALLOWED_EXCEPTIONS: r->u.allowed.filter - = add_ehspec_entry (ehspec, ttypes, r->u.allowed.type_list); + = add_ehspec_entry (&ehspec, &ttypes, r->u.allowed.type_list); break; default: break; } } - - ttypes.dispose (); - ehspec.dispose (); } /* Emit SEQ into basic block just before INSN (that is assumed to be @@ -1074,12 +1070,11 @@ static vec<int> sjlj_lp_call_site_index; static int sjlj_assign_call_site_values (void) { - action_hash_type ar_hash; + action_hash_type ar_hash (31); int i, disp_index; eh_landing_pad lp; vec_alloc (crtl->eh.action_record_data, 64); - ar_hash.create (31); disp_index = 0; call_site_base = 1; @@ -1089,7 +1084,7 @@ sjlj_assign_call_site_values (void) int action, call_site; /* First: build the action table. */ - action = collect_one_action_chain (ar_hash, lp->region); + action = collect_one_action_chain (&ar_hash, lp->region); /* Next: assign call-site values. If dwarf2 terms, this would be the region number assigned by convert_to_eh_region_ranges, but @@ -1108,8 +1103,6 @@ sjlj_assign_call_site_values (void) disp_index++; } - ar_hash.dispose (); - return disp_index; } @@ -2321,13 +2314,13 @@ expand_builtin_extend_pointer (tree addr_tree) } static int -add_action_record (action_hash_type ar_hash, int filter, int next) +add_action_record (action_hash_type *ar_hash, int filter, int next) { struct action_record **slot, *new_ar, tmp; tmp.filter = filter; tmp.next = next; - slot = ar_hash.find_slot (&tmp, INSERT); + slot = ar_hash->find_slot (&tmp, INSERT); if ((new_ar = *slot) == NULL) { @@ -2352,7 +2345,7 @@ add_action_record (action_hash_type ar_hash, int filter, int next) } static int -collect_one_action_chain (action_hash_type ar_hash, eh_region region) +collect_one_action_chain (action_hash_type *ar_hash, eh_region region) { int next; @@ -2481,7 +2474,7 @@ static unsigned int convert_to_eh_region_ranges (void) { rtx insn, iter, note; - action_hash_type ar_hash; + action_hash_type ar_hash (31); int last_action = -3; rtx last_action_insn = NULL_RTX; rtx last_landing_pad = NULL_RTX; @@ -2495,8 +2488,6 @@ convert_to_eh_region_ranges (void) vec_alloc (crtl->eh.action_record_data, 64); - ar_hash.create (31); - for (iter = get_insns (); iter ; iter = NEXT_INSN (iter)) if (INSN_P (iter)) { @@ -2515,7 +2506,7 @@ convert_to_eh_region_ranges (void) if (nothrow) continue; if (region) - this_action = collect_one_action_chain (ar_hash, region); + this_action = collect_one_action_chain (&ar_hash, region); else this_action = -1; @@ -2632,7 +2623,6 @@ convert_to_eh_region_ranges (void) call_site_base = saved_call_site_base; - ar_hash.dispose (); return 0; } diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 978b854a99c..f6b72b7a3a6 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -14686,7 +14686,7 @@ fold (tree expr) #undef fold static void fold_checksum_tree (const_tree, struct md5_ctx *, - hash_table <pointer_hash <tree_node> >); + hash_table<pointer_hash<tree_node> > *); static void fold_check_failed (const_tree, const_tree); void print_fold_checksum (const_tree); @@ -14700,20 +14700,18 @@ fold (tree expr) tree ret; struct md5_ctx ctx; unsigned char checksum_before[16], checksum_after[16]; - hash_table <pointer_hash <tree_node> > ht; + hash_table<pointer_hash<tree_node> > ht (32); - ht.create (32); md5_init_ctx (&ctx); - fold_checksum_tree (expr, &ctx, ht); + fold_checksum_tree (expr, &ctx, &ht); md5_finish_ctx (&ctx, checksum_before); ht.empty (); ret = fold_1 (expr); md5_init_ctx (&ctx); - fold_checksum_tree (expr, &ctx, ht); + fold_checksum_tree (expr, &ctx, &ht); md5_finish_ctx (&ctx, checksum_after); - ht.dispose (); if (memcmp (checksum_before, checksum_after, 16)) fold_check_failed (expr, ret); @@ -14726,13 +14724,11 @@ print_fold_checksum (const_tree expr) { struct md5_ctx ctx; unsigned char checksum[16], cnt; - hash_table <pointer_hash <tree_node> > ht; + hash_table<pointer_hash<tree_node> > ht (32); - ht.create (32); md5_init_ctx (&ctx); - fold_checksum_tree (expr, &ctx, ht); + fold_checksum_tree (expr, &ctx, &ht); md5_finish_ctx (&ctx, checksum); - ht.dispose (); for (cnt = 0; cnt < 16; ++cnt) fprintf (stderr, "%02x", checksum[cnt]); putc ('\n', stderr); @@ -14746,7 +14742,7 @@ fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UN static void fold_checksum_tree (const_tree expr, struct md5_ctx *ctx, - hash_table <pointer_hash <tree_node> > ht) + hash_table<pointer_hash <tree_node> > *ht) { tree_node **slot; enum tree_code code; @@ -14756,7 +14752,7 @@ fold_checksum_tree (const_tree expr, struct md5_ctx *ctx, recursive_label: if (expr == NULL) return; - slot = ht.find_slot (expr, INSERT); + slot = ht->find_slot (expr, INSERT); if (*slot != NULL) return; *slot = CONST_CAST_TREE (expr); @@ -14903,11 +14899,10 @@ debug_fold_checksum (const_tree t) int i; unsigned char checksum[16]; struct md5_ctx ctx; - hash_table <pointer_hash <tree_node> > ht; - ht.create (32); + hash_table<pointer_hash<tree_node> > ht (32); md5_init_ctx (&ctx); - fold_checksum_tree (t, &ctx, ht); + fold_checksum_tree (t, &ctx, &ht); md5_finish_ctx (&ctx, checksum); ht.empty (); @@ -14932,11 +14927,10 @@ fold_build1_stat_loc (location_t loc, #ifdef ENABLE_FOLD_CHECKING unsigned char checksum_before[16], checksum_after[16]; struct md5_ctx ctx; - hash_table <pointer_hash <tree_node> > ht; + hash_table<pointer_hash<tree_node> > ht (32); - ht.create (32); md5_init_ctx (&ctx); - fold_checksum_tree (op0, &ctx, ht); + fold_checksum_tree (op0, &ctx, &ht); md5_finish_ctx (&ctx, checksum_before); ht.empty (); #endif @@ -14947,9 +14941,8 @@ fold_build1_stat_loc (location_t loc, #ifdef ENABLE_FOLD_CHECKING md5_init_ctx (&ctx); - fold_checksum_tree (op0, &ctx, ht); + fold_checksum_tree (op0, &ctx, &ht); md5_finish_ctx (&ctx, checksum_after); - ht.dispose (); if (memcmp (checksum_before, checksum_after, 16)) fold_check_failed (op0, tem); @@ -14975,16 +14968,15 @@ fold_build2_stat_loc (location_t loc, checksum_after_op0[16], checksum_after_op1[16]; struct md5_ctx ctx; - hash_table <pointer_hash <tree_node> > ht; + hash_table<pointer_hash<tree_node> > ht (32); - ht.create (32); md5_init_ctx (&ctx); - fold_checksum_tree (op0, &ctx, ht); + fold_checksum_tree (op0, &ctx, &ht); md5_finish_ctx (&ctx, checksum_before_op0); ht.empty (); md5_init_ctx (&ctx); - fold_checksum_tree (op1, &ctx, ht); + fold_checksum_tree (op1, &ctx, &ht); md5_finish_ctx (&ctx, checksum_before_op1); ht.empty (); #endif @@ -14995,7 +14987,7 @@ fold_build2_stat_loc (location_t loc, #ifdef ENABLE_FOLD_CHECKING md5_init_ctx (&ctx); - fold_checksum_tree (op0, &ctx, ht); + fold_checksum_tree (op0, &ctx, &ht); md5_finish_ctx (&ctx, checksum_after_op0); ht.empty (); @@ -15003,9 +14995,8 @@ fold_build2_stat_loc (location_t loc, fold_check_failed (op0, tem); md5_init_ctx (&ctx); - fold_checksum_tree (op1, &ctx, ht); + fold_checksum_tree (op1, &ctx, &ht); md5_finish_ctx (&ctx, checksum_after_op1); - ht.dispose (); if (memcmp (checksum_before_op1, checksum_after_op1, 16)) fold_check_failed (op1, tem); @@ -15031,21 +15022,20 @@ fold_build3_stat_loc (location_t loc, enum tree_code code, tree type, checksum_after_op1[16], checksum_after_op2[16]; struct md5_ctx ctx; - hash_table <pointer_hash <tree_node> > ht; + hash_table<pointer_hash<tree_node> > ht (32); - ht.create (32); md5_init_ctx (&ctx); - fold_checksum_tree (op0, &ctx, ht); + fold_checksum_tree (op0, &ctx, &ht); md5_finish_ctx (&ctx, checksum_before_op0); ht.empty (); md5_init_ctx (&ctx); - fold_checksum_tree (op1, &ctx, ht); + fold_checksum_tree (op1, &ctx, &ht); md5_finish_ctx (&ctx, checksum_before_op1); ht.empty (); md5_init_ctx (&ctx); - fold_checksum_tree (op2, &ctx, ht); + fold_checksum_tree (op2, &ctx, &ht); md5_finish_ctx (&ctx, checksum_before_op2); ht.empty (); #endif @@ -15057,7 +15047,7 @@ fold_build3_stat_loc (location_t loc, enum tree_code code, tree type, #ifdef ENABLE_FOLD_CHECKING md5_init_ctx (&ctx); - fold_checksum_tree (op0, &ctx, ht); + fold_checksum_tree (op0, &ctx, &ht); md5_finish_ctx (&ctx, checksum_after_op0); ht.empty (); @@ -15065,7 +15055,7 @@ fold_build3_stat_loc (location_t loc, enum tree_code code, tree type, fold_check_failed (op0, tem); md5_init_ctx (&ctx); - fold_checksum_tree (op1, &ctx, ht); + fold_checksum_tree (op1, &ctx, &ht); md5_finish_ctx (&ctx, checksum_after_op1); ht.empty (); @@ -15073,9 +15063,8 @@ fold_build3_stat_loc (location_t loc, enum tree_code code, tree type, fold_check_failed (op1, tem); md5_init_ctx (&ctx); - fold_checksum_tree (op2, &ctx, ht); + fold_checksum_tree (op2, &ctx, &ht); md5_finish_ctx (&ctx, checksum_after_op2); - ht.dispose (); if (memcmp (checksum_before_op2, checksum_after_op2, 16)) fold_check_failed (op2, tem); @@ -15099,18 +15088,17 @@ fold_build_call_array_loc (location_t loc, tree type, tree fn, checksum_after_fn[16], checksum_after_arglist[16]; struct md5_ctx ctx; - hash_table <pointer_hash <tree_node> > ht; + hash_table<pointer_hash<tree_node> > ht (32); int i; - ht.create (32); md5_init_ctx (&ctx); - fold_checksum_tree (fn, &ctx, ht); + fold_checksum_tree (fn, &ctx, &ht); md5_finish_ctx (&ctx, checksum_before_fn); ht.empty (); md5_init_ctx (&ctx); for (i = 0; i < nargs; i++) - fold_checksum_tree (argarray[i], &ctx, ht); + fold_checksum_tree (argarray[i], &ctx, &ht); md5_finish_ctx (&ctx, checksum_before_arglist); ht.empty (); #endif @@ -15119,7 +15107,7 @@ fold_build_call_array_loc (location_t loc, tree type, tree fn, #ifdef ENABLE_FOLD_CHECKING md5_init_ctx (&ctx); - fold_checksum_tree (fn, &ctx, ht); + fold_checksum_tree (fn, &ctx, &ht); md5_finish_ctx (&ctx, checksum_after_fn); ht.empty (); @@ -15128,9 +15116,8 @@ fold_build_call_array_loc (location_t loc, tree type, tree fn, md5_init_ctx (&ctx); for (i = 0; i < nargs; i++) - fold_checksum_tree (argarray[i], &ctx, ht); + fold_checksum_tree (argarray[i], &ctx, &ht); md5_finish_ctx (&ctx, checksum_after_arglist); - ht.dispose (); if (memcmp (checksum_before_arglist, checksum_after_arglist, 16)) fold_check_failed (NULL_TREE, tem); diff --git a/gcc/gcse.c b/gcc/gcse.c index 8de596d2fac..a15b8bd6e70 100644 --- a/gcc/gcse.c +++ b/gcc/gcse.c @@ -386,7 +386,7 @@ pre_ldst_expr_hasher::equal (const value_type *ptr1, } /* Hashtable for the load/store memory refs. */ -static hash_table <pre_ldst_expr_hasher> pre_ldst_table; +static hash_table<pre_ldst_expr_hasher> *pre_ldst_table; /* Bitmap containing one bit for each register in the program. Used when performing GCSE to track which registers have been set since @@ -3762,7 +3762,7 @@ ldst_entry (rtx x) NULL, /*have_reg_qty=*/false); e.pattern = x; - slot = pre_ldst_table.find_slot_with_hash (&e, hash, INSERT); + slot = pre_ldst_table->find_slot_with_hash (&e, hash, INSERT); if (*slot) return *slot; @@ -3800,8 +3800,8 @@ free_ldst_entry (struct ls_expr * ptr) static void free_ld_motion_mems (void) { - if (pre_ldst_table.is_created ()) - pre_ldst_table.dispose (); + delete pre_ldst_table; + pre_ldst_table = NULL; while (pre_ldst_mems) { @@ -3857,10 +3857,10 @@ find_rtx_in_ldst (rtx x) { struct ls_expr e; ls_expr **slot; - if (!pre_ldst_table.is_created ()) + if (!pre_ldst_table) return NULL; e.pattern = x; - slot = pre_ldst_table.find_slot (&e, NO_INSERT); + slot = pre_ldst_table->find_slot (&e, NO_INSERT); if (!slot || (*slot)->invalid) return NULL; return *slot; @@ -3951,7 +3951,7 @@ compute_ld_motion_mems (void) rtx insn; pre_ldst_mems = NULL; - pre_ldst_table.create (13); + pre_ldst_table = new hash_table<pre_ldst_expr_hasher> (13); FOR_EACH_BB_FN (bb, cfun) { @@ -4053,7 +4053,7 @@ trim_ld_motion_mems (void) else { *last = ptr->next; - pre_ldst_table.remove_elt_with_hash (ptr, ptr->hash_index); + pre_ldst_table->remove_elt_with_hash (ptr, ptr->hash_index); free_ldst_entry (ptr); ptr = * last; } diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c index b11a10c0072..b88776bb40e 100644 --- a/gcc/ggc-common.c +++ b/gcc/ggc-common.c @@ -320,7 +320,7 @@ saving_hasher::equal (const value_type *p1, const compare_type *p2) return p1->obj == p2; } -static hash_table <saving_hasher> saving_htab; +static hash_table<saving_hasher> *saving_htab; /* Register an object in the hash table. */ @@ -334,7 +334,7 @@ gt_pch_note_object (void *obj, void *note_ptr_cookie, return 0; slot = (struct ptr_data **) - saving_htab.find_slot_with_hash (obj, POINTER_HASH (obj), INSERT); + saving_htab->find_slot_with_hash (obj, POINTER_HASH (obj), INSERT); if (*slot != NULL) { gcc_assert ((*slot)->note_ptr_fn == note_ptr_fn @@ -365,7 +365,7 @@ gt_pch_note_reorder (void *obj, void *note_ptr_cookie, return; data = (struct ptr_data *) - saving_htab.find_with_hash (obj, POINTER_HASH (obj)); + saving_htab->find_with_hash (obj, POINTER_HASH (obj)); gcc_assert (data && data->note_ptr_cookie == note_ptr_cookie); data->reorder_fn = reorder_fn; @@ -431,7 +431,7 @@ relocate_ptrs (void *ptr_p, void *state_p) return; result = (struct ptr_data *) - saving_htab.find_with_hash (*ptr, POINTER_HASH (*ptr)); + saving_htab->find_with_hash (*ptr, POINTER_HASH (*ptr)); gcc_assert (result); *ptr = result->new_addr; } @@ -460,7 +460,7 @@ write_pch_globals (const struct ggc_root_tab * const *tab, else { new_ptr = (struct ptr_data *) - saving_htab.find_with_hash (ptr, POINTER_HASH (ptr)); + saving_htab->find_with_hash (ptr, POINTER_HASH (ptr)); if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f) != 1) fatal_error ("can%'t write PCH file: %m"); @@ -494,7 +494,7 @@ gt_pch_save (FILE *f) gt_pch_save_stringpool (); timevar_push (TV_PCH_PTR_REALLOC); - saving_htab.create (50000); + saving_htab = new hash_table<saving_hasher> (50000); for (rt = gt_ggc_rtab; *rt; rt++) for (rti = *rt; rti->base != NULL; rti++) @@ -510,7 +510,7 @@ gt_pch_save (FILE *f) state.f = f; state.d = init_ggc_pch (); state.count = 0; - saving_htab.traverse <traversal_state *, ggc_call_count> (&state); + saving_htab->traverse <traversal_state *, ggc_call_count> (&state); mmi.size = ggc_pch_total_size (state.d); @@ -526,7 +526,7 @@ gt_pch_save (FILE *f) state.ptrs = XNEWVEC (struct ptr_data *, state.count); state.ptrs_i = 0; - saving_htab.traverse <traversal_state *, ggc_call_alloc> (&state); + saving_htab->traverse <traversal_state *, ggc_call_alloc> (&state); timevar_pop (TV_PCH_PTR_REALLOC); timevar_push (TV_PCH_PTR_SORT); @@ -655,7 +655,8 @@ gt_pch_save (FILE *f) XDELETE (state.ptrs); XDELETE (this_object); - saving_htab.dispose (); + delete saving_htab; + saving_htab = NULL; } /* Read the state of the compiler back in from F. */ @@ -939,7 +940,7 @@ loc_desc_hasher::equal (const value_type *d, const compare_type *d2) } /* Hashtable used for statistics. */ -static hash_table <loc_desc_hasher> loc_hash; +static hash_table<loc_desc_hasher> *loc_hash; struct ptr_hash_entry { @@ -971,7 +972,7 @@ ptr_hash_hasher::equal (const value_type *p, const compare_type *p2) } /* Hashtable converting address of allocated field to loc descriptor. */ -static hash_table <ptr_hash_hasher> ptr_hash; +static hash_table<ptr_hash_hasher> *ptr_hash; /* Return descriptor for given call site, create new one if needed. */ static struct loc_descriptor * @@ -983,10 +984,10 @@ make_loc_descriptor (const char *name, int line, const char *function) loc.file = name; loc.line = line; loc.function = function; - if (!loc_hash.is_created ()) - loc_hash.create (10); + if (!loc_hash) + loc_hash = new hash_table<loc_desc_hasher> (10); - slot = loc_hash.find_slot (&loc, INSERT); + slot = loc_hash->find_slot (&loc, INSERT); if (*slot) return *slot; *slot = XCNEW (struct loc_descriptor); @@ -1008,9 +1009,9 @@ ggc_record_overhead (size_t allocated, size_t overhead, void *ptr, p->ptr = ptr; p->loc = loc; p->size = allocated + overhead; - if (!ptr_hash.is_created ()) - ptr_hash.create (10); - slot = ptr_hash.find_slot_with_hash (ptr, htab_hash_pointer (ptr), INSERT); + if (!ptr_hash) + ptr_hash = new hash_table<ptr_hash_hasher> (10); + slot = ptr_hash->find_slot_with_hash (ptr, htab_hash_pointer (ptr), INSERT); gcc_assert (!*slot); *slot = p; @@ -1028,7 +1029,7 @@ ggc_prune_ptr (ptr_hash_entry **slot, void *b ATTRIBUTE_UNUSED) if (!ggc_marked_p (p->ptr)) { p->loc->collected += p->size; - ptr_hash.clear_slot (slot); + ptr_hash->clear_slot (slot); free (p); } return 1; @@ -1039,15 +1040,15 @@ ggc_prune_ptr (ptr_hash_entry **slot, void *b ATTRIBUTE_UNUSED) void ggc_prune_overhead_list (void) { - ptr_hash.traverse <void *, ggc_prune_ptr> (NULL); + ptr_hash->traverse <void *, ggc_prune_ptr> (NULL); } /* Notice that the pointer has been freed. */ void ggc_free_overhead (void *ptr) { - ptr_hash_entry **slot; - slot = ptr_hash.find_slot_with_hash (ptr, htab_hash_pointer (ptr), NO_INSERT); + ptr_hash_entry **slot + = ptr_hash->find_slot_with_hash (ptr, htab_hash_pointer (ptr), NO_INSERT); struct ptr_hash_entry *p; /* The pointer might be not found if a PCH read happened between allocation and ggc_free () call. FIXME: account memory properly in the presence of @@ -1056,7 +1057,7 @@ ggc_free_overhead (void *ptr) return; p = (struct ptr_hash_entry *) *slot; p->loc->freed += p->size; - ptr_hash.clear_slot (slot); + ptr_hash->clear_slot (slot); free (p); } @@ -1120,12 +1121,12 @@ dump_ggc_loc_statistics (bool final) ggc_collect (); loc_array = XCNEWVEC (struct loc_descriptor *, - loc_hash.elements_with_deleted ()); + loc_hash->elements_with_deleted ()); fprintf (stderr, "-------------------------------------------------------\n"); fprintf (stderr, "\n%-48s %10s %10s %10s %10s %10s\n", "source location", "Garbage", "Freed", "Leak", "Overhead", "Times"); fprintf (stderr, "-------------------------------------------------------\n"); - loc_hash.traverse <int *, ggc_add_statistics> (&nentries); + loc_hash->traverse <int *, ggc_add_statistics> (&nentries); qsort (loc_array, nentries, sizeof (*loc_array), final ? final_cmp_statistic : cmp_statistic); for (i = 0; i < nentries; i++) diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c index fae2c562b32..c5944fa9c01 100644 --- a/gcc/gimple-ssa-strength-reduction.c +++ b/gcc/gimple-ssa-strength-reduction.c @@ -430,7 +430,7 @@ cand_chain_hasher::equal (const value_type *chain1, const compare_type *chain2) } /* Hash table embodying a mapping from base exprs to chains of candidates. */ -static hash_table <cand_chain_hasher> base_cand_map; +static hash_table<cand_chain_hasher> *base_cand_map; /* Pointer map used by tree_to_aff_combination_expand. */ static struct pointer_map_t *name_expansions; @@ -507,7 +507,7 @@ find_basis_for_base_expr (slsr_cand_t c, tree base_expr) int max_iters = PARAM_VALUE (PARAM_MAX_SLSR_CANDIDATE_SCAN); mapping_key.base_expr = base_expr; - chain = base_cand_map.find (&mapping_key); + chain = base_cand_map->find (&mapping_key); for (; chain && iters < max_iters; chain = chain->next, ++iters) { @@ -604,7 +604,7 @@ record_potential_basis (slsr_cand_t c, tree base) node->base_expr = base; node->cand = c; node->next = NULL; - slot = base_cand_map.find_slot (node, INSERT); + slot = base_cand_map->find_slot (node, INSERT); if (*slot) { @@ -1848,7 +1848,8 @@ static void dump_cand_chains (void) { fprintf (dump_file, "\nStrength reduction candidate chains:\n\n"); - base_cand_map.traverse_noresize <void *, ssa_base_cand_dump_callback> (NULL); + base_cand_map->traverse_noresize <void *, ssa_base_cand_dump_callback> + (NULL); fputs ("\n", dump_file); } @@ -3634,7 +3635,7 @@ pass_strength_reduction::execute (function *fun) gcc_obstack_init (&chain_obstack); /* Allocate the mapping from base expressions to candidate chains. */ - base_cand_map.create (500); + base_cand_map = new hash_table<cand_chain_hasher> (500); /* Allocate the mapping from bases to alternative bases. */ alt_base_map = pointer_map_create (); @@ -3661,7 +3662,8 @@ pass_strength_reduction::execute (function *fun) analyze_candidates_and_replace (); loop_optimizer_finalize (); - base_cand_map.dispose (); + delete base_cand_map; + base_cand_map = NULL; obstack_free (&chain_obstack, NULL); pointer_map_destroy (stmt_cand_map); cand_vec.release (); diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 69f6d5b9c61..6bea3c67efe 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -121,7 +121,7 @@ struct gimplify_ctx vec<tree> case_labels; /* The formal temporary table. Should this be persistent? */ - hash_table <gimplify_hasher> temp_htab; + hash_table<gimplify_hasher> *temp_htab; int conditions; bool save_stack; @@ -256,8 +256,8 @@ pop_gimplify_context (gimple body) else record_vars (c->temps); - if (c->temp_htab.is_created ()) - c->temp_htab.dispose (); + delete c->temp_htab; + c->temp_htab = NULL; ctx_free (c); } @@ -484,9 +484,9 @@ lookup_tmp_var (tree val, bool is_formal) elt_t **slot; elt.val = val; - if (!gimplify_ctxp->temp_htab.is_created ()) - gimplify_ctxp->temp_htab.create (1000); - slot = gimplify_ctxp->temp_htab.find_slot (&elt, INSERT); + if (!gimplify_ctxp->temp_htab) + gimplify_ctxp->temp_htab = new hash_table<gimplify_hasher> (1000); + slot = gimplify_ctxp->temp_htab->find_slot (&elt, INSERT); if (*slot == NULL) { elt_p = XNEW (elt_t); diff --git a/gcc/graphite-clast-to-gimple.c b/gcc/graphite-clast-to-gimple.c index 9ac9b67bb79..ad30909220e 100644 --- a/gcc/graphite-clast-to-gimple.c +++ b/gcc/graphite-clast-to-gimple.c @@ -183,7 +183,7 @@ clast_index_hasher::remove (value_type *c) free (c); } -typedef hash_table <clast_index_hasher> clast_index_htab_type; +typedef hash_table<clast_index_hasher> clast_index_htab_type; /* Returns a pointer to a new element of type clast_name_index_p built from NAME, INDEX, LEVEL, BOUND_ONE, and BOUND_TWO. */ @@ -213,7 +213,7 @@ new_clast_name_index (const char *name, int index, int level, vector of parameters. */ static inline int -clast_name_to_level (clast_name_p name, clast_index_htab_type index_table) +clast_name_to_level (clast_name_p name, clast_index_htab_type *index_table) { struct clast_name_index tmp; clast_name_index **slot; @@ -222,7 +222,7 @@ clast_name_to_level (clast_name_p name, clast_index_htab_type index_table) tmp.name = ((const struct clast_name *) name)->name; tmp.free_name = NULL; - slot = index_table.find_slot (&tmp, NO_INSERT); + slot = index_table->find_slot (&tmp, NO_INSERT); if (slot && *slot) return ((struct clast_name_index *) *slot)->level; @@ -235,7 +235,7 @@ clast_name_to_level (clast_name_p name, clast_index_htab_type index_table) SCATTERING_DIMENSIONS vector. */ static inline int -clast_name_to_index (struct clast_name *name, clast_index_htab_type index_table) +clast_name_to_index (struct clast_name *name, clast_index_htab_type *index_table) { struct clast_name_index tmp; clast_name_index **slot; @@ -243,7 +243,7 @@ clast_name_to_index (struct clast_name *name, clast_index_htab_type index_table) tmp.name = ((const struct clast_name *) name)->name; tmp.free_name = NULL; - slot = index_table.find_slot (&tmp, NO_INSERT); + slot = index_table->find_slot (&tmp, NO_INSERT); if (slot && *slot) return (*slot)->index; @@ -256,8 +256,9 @@ clast_name_to_index (struct clast_name *name, clast_index_htab_type index_table) found in the INDEX_TABLE, false otherwise. */ static inline bool -clast_name_to_lb_ub (struct clast_name *name, clast_index_htab_type index_table, - mpz_t bound_one, mpz_t bound_two) +clast_name_to_lb_ub (struct clast_name *name, + clast_index_htab_type *index_table, mpz_t bound_one, + mpz_t bound_two) { struct clast_name_index tmp; clast_name_index **slot; @@ -265,7 +266,7 @@ clast_name_to_lb_ub (struct clast_name *name, clast_index_htab_type index_table, tmp.name = name->name; tmp.free_name = NULL; - slot = index_table.find_slot (&tmp, NO_INSERT); + slot = index_table->find_slot (&tmp, NO_INSERT); if (slot && *slot) { @@ -280,7 +281,7 @@ clast_name_to_lb_ub (struct clast_name *name, clast_index_htab_type index_table, /* Records in INDEX_TABLE the INDEX and LEVEL for NAME. */ static inline void -save_clast_name_index (clast_index_htab_type index_table, const char *name, +save_clast_name_index (clast_index_htab_type *index_table, const char *name, int index, int level, mpz_t bound_one, mpz_t bound_two) { struct clast_name_index tmp; @@ -288,7 +289,7 @@ save_clast_name_index (clast_index_htab_type index_table, const char *name, tmp.name = name; tmp.free_name = NULL; - slot = index_table.find_slot (&tmp, INSERT); + slot = index_table->find_slot (&tmp, INSERT); if (slot) { @@ -307,7 +308,7 @@ save_clast_name_index (clast_index_htab_type index_table, const char *name, typedef struct ivs_params { vec<tree> params, *newivs; - clast_index_htab_type newivs_index, params_index; + clast_index_htab_type *newivs_index, *params_index; sese region; } *ivs_params_p; @@ -319,7 +320,7 @@ clast_name_to_gcc (struct clast_name *name, ivs_params_p ip) { int index; - if (ip->params.exists () && ip->params_index.is_created ()) + if (ip->params.exists () && ip->params_index) { index = clast_name_to_index (name, ip->params_index); @@ -327,7 +328,7 @@ clast_name_to_gcc (struct clast_name *name, ivs_params_p ip) return ip->params[index]; } - gcc_assert (ip->newivs && ip->newivs_index.is_created ()); + gcc_assert (ip->newivs && ip->newivs_index); index = clast_name_to_index (name, ip->newivs_index); gcc_assert (index >= 0); @@ -718,12 +719,12 @@ type_for_clast_name (struct clast_name *name, ivs_params_p ip, mpz_t bound_one, { bool found = false; - if (ip->params.exists () && ip->params_index.is_created ()) + if (ip->params.exists () && ip->params_index) found = clast_name_to_lb_ub (name, ip->params_index, bound_one, bound_two); if (!found) { - gcc_assert (ip->newivs && ip->newivs_index.is_created ()); + gcc_assert (ip->newivs && ip->newivs_index); found = clast_name_to_lb_ub (name, ip->newivs_index, bound_one, bound_two); gcc_assert (found); @@ -1029,13 +1030,13 @@ new_bb_pbb_def (basic_block bb, poly_bb_p pbb) static void mark_bb_with_pbb (poly_bb_p pbb, basic_block bb, - bb_pbb_htab_type bb_pbb_mapping) + bb_pbb_htab_type *bb_pbb_mapping) { bb_pbb_def tmp; bb_pbb_def **x; tmp.bb = bb; - x = bb_pbb_mapping.find_slot (&tmp, INSERT); + x = bb_pbb_mapping->find_slot (&tmp, INSERT); if (x && !*x) *x = new_bb_pbb_def (bb, pbb); @@ -1044,13 +1045,13 @@ mark_bb_with_pbb (poly_bb_p pbb, basic_block bb, /* Find BB's related poly_bb_p in hash table BB_PBB_MAPPING. */ poly_bb_p -find_pbb_via_hash (bb_pbb_htab_type bb_pbb_mapping, basic_block bb) +find_pbb_via_hash (bb_pbb_htab_type *bb_pbb_mapping, basic_block bb) { bb_pbb_def tmp; bb_pbb_def **slot; tmp.bb = bb; - slot = bb_pbb_mapping.find_slot (&tmp, NO_INSERT); + slot = bb_pbb_mapping->find_slot (&tmp, NO_INSERT); if (slot && *slot) return ((bb_pbb_def *) *slot)->pbb; @@ -1064,7 +1065,7 @@ find_pbb_via_hash (bb_pbb_htab_type bb_pbb_mapping, basic_block bb) related poly_bb_p. */ scop_p -get_loop_body_pbbs (loop_p loop, bb_pbb_htab_type bb_pbb_mapping, +get_loop_body_pbbs (loop_p loop, bb_pbb_htab_type *bb_pbb_mapping, vec<poly_bb_p> *pbbs) { unsigned i; @@ -1094,7 +1095,7 @@ get_loop_body_pbbs (loop_p loop, bb_pbb_htab_type bb_pbb_mapping, static edge translate_clast_user (struct clast_user_stmt *stmt, edge next_e, - bb_pbb_htab_type bb_pbb_mapping, ivs_params_p ip) + bb_pbb_htab_type *bb_pbb_mapping, ivs_params_p ip) { int i, nb_loops; basic_block new_bb; @@ -1163,7 +1164,7 @@ graphite_create_new_loop_guard (edge entry_edge, struct clast_for *stmt, } static edge -translate_clast (loop_p, struct clast_stmt *, edge, bb_pbb_htab_type, +translate_clast (loop_p, struct clast_stmt *, edge, bb_pbb_htab_type *, int, ivs_params_p); /* Create the loop for a clast for statement. @@ -1173,7 +1174,7 @@ translate_clast (loop_p, struct clast_stmt *, edge, bb_pbb_htab_type, static edge translate_clast_for_loop (loop_p context_loop, struct clast_for *stmt, - edge next_e, bb_pbb_htab_type bb_pbb_mapping, + edge next_e, bb_pbb_htab_type *bb_pbb_mapping, int level, tree type, tree lb, tree ub, ivs_params_p ip) { @@ -1211,7 +1212,7 @@ translate_clast_for_loop (loop_p context_loop, struct clast_for *stmt, static edge translate_clast_for (loop_p context_loop, struct clast_for *stmt, edge next_e, - bb_pbb_htab_type bb_pbb_mapping, int level, + bb_pbb_htab_type *bb_pbb_mapping, int level, ivs_params_p ip) { tree type, lb, ub; @@ -1270,7 +1271,7 @@ translate_clast_assignment (struct clast_assignment *stmt, edge next_e, static edge translate_clast_guard (loop_p context_loop, struct clast_guard *stmt, - edge next_e, bb_pbb_htab_type bb_pbb_mapping, int level, + edge next_e, bb_pbb_htab_type *bb_pbb_mapping, int level, ivs_params_p ip) { edge last_e = graphite_create_new_guard (next_e, stmt, ip); @@ -1289,7 +1290,7 @@ translate_clast_guard (loop_p context_loop, struct clast_guard *stmt, static edge translate_clast (loop_p context_loop, struct clast_stmt *stmt, edge next_e, - bb_pbb_htab_type bb_pbb_mapping, int level, ivs_params_p ip) + bb_pbb_htab_type *bb_pbb_mapping, int level, ivs_params_p ip) { if (!stmt) return next_e; @@ -1331,7 +1332,7 @@ translate_clast (loop_p context_loop, struct clast_stmt *stmt, edge next_e, static CloogUnionDomain * add_names_to_union_domain (scop_p scop, CloogUnionDomain *union_domain, int nb_scattering_dims, - clast_index_htab_type params_index) + clast_index_htab_type *params_index) { sese region = SCOP_REGION (scop); int i; @@ -1582,7 +1583,7 @@ int get_max_scattering_dimensions (scop_p scop) } static CloogInput * -generate_cloog_input (scop_p scop, clast_index_htab_type params_index) +generate_cloog_input (scop_p scop, clast_index_htab_type *params_index) { CloogUnionDomain *union_domain; CloogInput *cloog_input; @@ -1605,7 +1606,7 @@ generate_cloog_input (scop_p scop, clast_index_htab_type params_index) without a program. */ static struct clast_stmt * -scop_to_clast (scop_p scop, clast_index_htab_type params_index) +scop_to_clast (scop_p scop, clast_index_htab_type *params_index) { CloogInput *cloog_input; struct clast_stmt *clast; @@ -1634,11 +1635,9 @@ void print_generated_program (FILE *file, scop_p scop) { CloogOptions *options = set_cloog_options (); - clast_index_htab_type params_index; + clast_index_htab_type *params_index = new clast_index_htab_type (10); struct clast_stmt *clast; - params_index.create (10); - clast = scop_to_clast (scop, params_index); fprintf (file, " (clast: \n"); @@ -1663,20 +1662,20 @@ debug_generated_program (scop_p scop) */ bool -gloog (scop_p scop, bb_pbb_htab_type bb_pbb_mapping) +gloog (scop_p scop, bb_pbb_htab_type *bb_pbb_mapping) { auto_vec<tree, 10> newivs; loop_p context_loop; sese region = SCOP_REGION (scop); ifsese if_region = NULL; - clast_index_htab_type newivs_index, params_index; + clast_index_htab_type *newivs_index, *params_index; struct clast_stmt *clast; struct ivs_params ip; timevar_push (TV_GRAPHITE_CODE_GEN); gloog_error = false; - params_index.create (10); + params_index = new clast_index_htab_type (10); clast = scop_to_clast (scop, params_index); @@ -1699,7 +1698,7 @@ gloog (scop_p scop, bb_pbb_htab_type bb_pbb_mapping) graphite_verify (); context_loop = SESE_ENTRY (region)->src->loop_father; - newivs_index.create (10); + newivs_index= new clast_index_htab_type (10); ip.newivs = &newivs; ip.newivs_index = newivs_index; @@ -1721,8 +1720,10 @@ gloog (scop_p scop, bb_pbb_htab_type bb_pbb_mapping) free (if_region->region); free (if_region); - newivs_index.dispose (); - params_index.dispose (); + delete newivs_index; + newivs_index = NULL; + delete params_index; + params_index = NULL; cloog_clast_free (clast); timevar_pop (TV_GRAPHITE_CODE_GEN); diff --git a/gcc/graphite-dependences.c b/gcc/graphite-dependences.c index b0f868077ae..8c90c8e434f 100644 --- a/gcc/graphite-dependences.c +++ b/gcc/graphite-dependences.c @@ -587,7 +587,7 @@ loop_level_carries_dependences (scop_p scop, vec<poly_bb_p> body, poly_bb_p. */ bool -loop_is_parallel_p (loop_p loop, bb_pbb_htab_type bb_pbb_mapping, int depth) +loop_is_parallel_p (loop_p loop, bb_pbb_htab_type *bb_pbb_mapping, int depth) { bool dependences; scop_p scop; diff --git a/gcc/graphite-htab.h b/gcc/graphite-htab.h index d67dd0cb363..ee2507f87ed 100644 --- a/gcc/graphite-htab.h +++ b/gcc/graphite-htab.h @@ -50,11 +50,11 @@ bb_pbb_hasher::equal (const value_type *bp1, const compare_type *bp2) return (bp1->bb->index == bp2->bb->index); } -typedef hash_table <bb_pbb_hasher> bb_pbb_htab_type; +typedef hash_table<bb_pbb_hasher> bb_pbb_htab_type; -extern bool gloog (scop_p, bb_pbb_htab_type); -poly_bb_p find_pbb_via_hash (bb_pbb_htab_type, basic_block); -bool loop_is_parallel_p (loop_p, bb_pbb_htab_type, int); -scop_p get_loop_body_pbbs (loop_p, bb_pbb_htab_type, vec<poly_bb_p> *); +extern bool gloog (scop_p, bb_pbb_htab_type *); +poly_bb_p find_pbb_via_hash (bb_pbb_htab_type *, basic_block); +bool loop_is_parallel_p (loop_p, bb_pbb_htab_type *, int); +scop_p get_loop_body_pbbs (loop_p, bb_pbb_htab_type *, vec<poly_bb_p> *); #endif diff --git a/gcc/graphite.c b/gcc/graphite.c index eedda4cf1d3..5d1e8706bfd 100644 --- a/gcc/graphite.c +++ b/gcc/graphite.c @@ -269,7 +269,6 @@ graphite_transform_loops (void) scop_p scop; bool need_cfg_cleanup_p = false; vec<scop_p> scops = vNULL; - bb_pbb_htab_type bb_pbb_mapping; isl_ctx *ctx; /* If a function is parallel it was most probably already run through graphite @@ -291,8 +290,7 @@ graphite_transform_loops (void) print_global_statistics (dump_file); } - bb_pbb_mapping.create (10); - + bb_pbb_htab_type bb_pbb_mapping (10); FOR_EACH_VEC_ELT (scops, i, scop) if (dbg_cnt (graphite_scop)) { @@ -301,11 +299,10 @@ graphite_transform_loops (void) if (POLY_SCOP_P (scop) && apply_poly_transforms (scop) - && gloog (scop, bb_pbb_mapping)) + && gloog (scop, &bb_pbb_mapping)) need_cfg_cleanup_p = true; } - bb_pbb_mapping.dispose (); free_scops (scops); graphite_finalize (need_cfg_cleanup_p); the_isl_ctx = NULL; diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c index 0e1800a6332..f93fe4ca099 100644 --- a/gcc/haifa-sched.c +++ b/gcc/haifa-sched.c @@ -651,8 +651,8 @@ delay_i2_hasher::equal (const value_type *x, const compare_type *y) /* Two hash tables to record delay_pairs, one indexed by I1 and the other indexed by I2. */ -static hash_table <delay_i1_hasher> delay_htab; -static hash_table <delay_i2_hasher> delay_htab_i2; +static hash_table<delay_i1_hasher> *delay_htab; +static hash_table<delay_i2_hasher> *delay_htab_i2; /* Called through htab_traverse. Walk the hashtable using I2 as index, and delete all elements involving an UID higher than @@ -664,7 +664,7 @@ haifa_htab_i2_traverse (delay_pair **slot, int *data) struct delay_pair *p = *slot; if (INSN_UID (p->i2) >= maxuid || INSN_UID (p->i1) >= maxuid) { - delay_htab_i2.clear_slot (slot); + delay_htab_i2->clear_slot (slot); } return 1; } @@ -680,7 +680,7 @@ haifa_htab_i1_traverse (delay_pair **pslot, int *data) if (INSN_UID ((*pslot)->i1) >= maxuid) { - delay_htab.clear_slot (pslot); + delay_htab->clear_slot (pslot); return 1; } pprev = &first; @@ -694,7 +694,7 @@ haifa_htab_i1_traverse (delay_pair **pslot, int *data) } *pprev = NULL; if (first == NULL) - delay_htab.clear_slot (pslot); + delay_htab->clear_slot (pslot); else *pslot = first; return 1; @@ -705,8 +705,8 @@ haifa_htab_i1_traverse (delay_pair **pslot, int *data) void discard_delay_pairs_above (int max_uid) { - delay_htab.traverse <int *, haifa_htab_i1_traverse> (&max_uid); - delay_htab_i2.traverse <int *, haifa_htab_i2_traverse> (&max_uid); + delay_htab->traverse <int *, haifa_htab_i1_traverse> (&max_uid); + delay_htab_i2->traverse <int *, haifa_htab_i2_traverse> (&max_uid); } /* This function can be called by a port just before it starts the final @@ -736,15 +736,15 @@ record_delay_slot_pair (rtx i1, rtx i2, int cycles, int stages) p->cycles = cycles; p->stages = stages; - if (!delay_htab.is_created ()) + if (!delay_htab) { - delay_htab.create (10); - delay_htab_i2.create (10); + delay_htab = new hash_table<delay_i1_hasher> (10); + delay_htab_i2 = new hash_table<delay_i2_hasher> (10); } - slot = delay_htab.find_slot_with_hash (i1, htab_hash_pointer (i1), INSERT); + slot = delay_htab->find_slot_with_hash (i1, htab_hash_pointer (i1), INSERT); p->next_same_i1 = *slot; *slot = p; - slot = delay_htab_i2.find_slot_with_hash (i2, htab_hash_pointer (i2), INSERT); + slot = delay_htab_i2->find_slot (p, INSERT); *slot = p; } @@ -755,10 +755,10 @@ real_insn_for_shadow (rtx insn) { struct delay_pair *pair; - if (!delay_htab.is_created ()) + if (!delay_htab) return NULL_RTX; - pair = delay_htab_i2.find_with_hash (insn, htab_hash_pointer (insn)); + pair = delay_htab_i2->find_with_hash (insn, htab_hash_pointer (insn)); if (!pair || pair->stages > 0) return NULL_RTX; return pair->i1; @@ -786,10 +786,10 @@ add_delay_dependencies (rtx insn) sd_iterator_def sd_it; dep_t dep; - if (!delay_htab.is_created ()) + if (!delay_htab) return; - pair = delay_htab_i2.find_with_hash (insn, htab_hash_pointer (insn)); + pair = delay_htab_i2->find_with_hash (insn, htab_hash_pointer (insn)); if (!pair) return; add_dependence (insn, pair->i1, REG_DEP_ANTI); @@ -800,7 +800,7 @@ add_delay_dependencies (rtx insn) { rtx pro = DEP_PRO (dep); struct delay_pair *other_pair - = delay_htab_i2.find_with_hash (pro, htab_hash_pointer (pro)); + = delay_htab_i2->find_with_hash (pro, htab_hash_pointer (pro)); if (!other_pair || other_pair->stages) continue; if (pair_delay (other_pair) >= pair_delay (pair)) @@ -1421,11 +1421,11 @@ dep_cost_1 (dep_t link, dw_t dw) if (DEP_COST (link) != UNKNOWN_DEP_COST) return DEP_COST (link); - if (delay_htab.is_created ()) + if (delay_htab) { struct delay_pair *delay_entry; delay_entry - = delay_htab_i2.find_with_hash (used, htab_hash_pointer (used)); + = delay_htab_i2->find_with_hash (used, htab_hash_pointer (used)); if (delay_entry) { if (delay_entry->i1 == insn) @@ -5779,12 +5779,12 @@ prune_ready_list (state_t temp_state, bool first_cycle_insn_p, { int delay_cost = 0; - if (delay_htab.is_created ()) + if (delay_htab) { struct delay_pair *delay_entry; delay_entry - = delay_htab.find_with_hash (insn, - htab_hash_pointer (insn)); + = delay_htab->find_with_hash (insn, + htab_hash_pointer (insn)); while (delay_entry && delay_cost == 0) { delay_cost = estimate_shadow_tick (delay_entry); @@ -6278,13 +6278,13 @@ schedule_block (basic_block *target_bb, state_t init_state) goto restart_choose_ready; } - if (delay_htab.is_created ()) + if (delay_htab) { /* If this insn is the first part of a delay-slot pair, record a backtrack point. */ struct delay_pair *delay_entry; delay_entry - = delay_htab.find_with_hash (insn, htab_hash_pointer (insn)); + = delay_htab->find_with_hash (insn, htab_hash_pointer (insn)); if (delay_entry) { save_backtrack_point (delay_entry, ls); @@ -6873,10 +6873,10 @@ sched_finish (void) void free_delay_pairs (void) { - if (delay_htab.is_created ()) + if (delay_htab) { - delay_htab.empty (); - delay_htab_i2.empty (); + delay_htab->empty (); + delay_htab_i2->empty (); } } diff --git a/gcc/hash-table.h b/gcc/hash-table.h index 034385c19f2..41cc19e52fb 100644 --- a/gcc/hash-table.h +++ b/gcc/hash-table.h @@ -60,12 +60,6 @@ along with GCC; see the file COPYING3. If not see is allocated. This type is called the allocator type. It is parameterized on the value type. It provides four functions. - - A static member function named 'control_alloc'. This function - allocates the control data blocks for the table. - - - A static member function named 'control_free'. This function - frees the control data blocks for the table. - - A static member function named 'data_alloc'. This function allocates the data elements in the table. @@ -211,23 +205,11 @@ along with GCC; see the file COPYING3. If not see template <typename Type> struct xcallocator { - static Type *control_alloc (size_t count); static Type *data_alloc (size_t count); - static void control_free (Type *memory); static void data_free (Type *memory); }; -/* Allocate memory for COUNT control blocks. */ - -template <typename Type> -inline Type * -xcallocator <Type>::control_alloc (size_t count) -{ - return static_cast <Type *> (xcalloc (count, sizeof (Type))); -} - - /* Allocate memory for COUNT data blocks. */ template <typename Type> @@ -238,16 +220,6 @@ xcallocator <Type>::data_alloc (size_t count) } -/* Free memory for control blocks. */ - -template <typename Type> -inline void -xcallocator <Type>::control_free (Type *memory) -{ - return ::free (memory); -} - - /* Free memory for data blocks. */ template <typename Type> @@ -348,37 +320,6 @@ extern hashval_t hash_table_mod1 (hashval_t hash, unsigned int index); extern hashval_t hash_table_mod2 (hashval_t hash, unsigned int index); -/* Internal implementation type. */ - -template <typename T> -struct hash_table_control -{ - /* Table itself. */ - T **entries; - - /* Current size (in entries) of the hash table. */ - size_t size; - - /* Current number of elements including also deleted elements. */ - size_t n_elements; - - /* Current number of deleted elements in the table. */ - size_t n_deleted; - - /* The following member is used for debugging. Its value is number - of all calls of `htab_find_slot' for the hash table. */ - unsigned int searches; - - /* The following member is used for debugging. Its value is number - of collisions fixed for time of work with the hash table. */ - unsigned int collisions; - - /* Current size (in entries) of the hash table, as an index into the - table of primes. */ - unsigned int size_prime_index; -}; - - /* User-facing hash table type. The table stores elements of type Descriptor::value_type. @@ -400,213 +341,174 @@ struct hash_table_control The default is xcallocator. */ - template <typename Descriptor, - template <typename Type> class Allocator = xcallocator> + template<typename Type> class Allocator= xcallocator> class hash_table { -public: typedef typename Descriptor::value_type value_type; typedef typename Descriptor::compare_type compare_type; - class iterator - { - public: - inline iterator (); - inline iterator (value_type **, value_type **); - inline value_type &operator * (); - void slide (); - inline iterator &operator ++ (); - inline bool operator != (const iterator &) const; - private: - value_type **m_slot; - value_type **m_limit; - }; - -private: - hash_table_control <value_type> *htab; - - value_type **find_empty_slot_for_expand (hashval_t hash); - void expand (); - public: - hash_table (); - void create (size_t initial_slots); - bool is_created (); - void dispose (); - value_type *find (const value_type *value); - value_type *find_with_hash (const compare_type *comparable, hashval_t hash); - value_type **find_slot (const value_type *value, enum insert_option insert); - value_type **find_slot_with_hash (const compare_type *comparable, - hashval_t hash, enum insert_option insert); - void empty (); - void clear_slot (value_type **slot); - void remove_elt (const value_type *value); - void remove_elt_with_hash (const compare_type *comparable, hashval_t hash); - size_t size (); - size_t elements (); - size_t elements_with_deleted (); - double collisions (); - - template <typename Argument, - int (*Callback) (value_type **slot, Argument argument)> - void traverse_noresize (Argument argument); - - template <typename Argument, - int (*Callback) (value_type **slot, Argument argument)> - void traverse (Argument argument); + hash_table (size_t); + ~hash_table (); - iterator begin (); - iterator end (); -}; + /* Current size (in entries) of the hash table. */ + size_t size () const { return m_size; } + /* Return the current number of elements in this hash table. */ + size_t elements () const { return m_n_elements - m_n_deleted; } -/* Construct the hash table. The only useful operation next is create. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -inline -hash_table <Descriptor, Allocator>::hash_table () -: htab (NULL) -{ -} + /* Return the current number of elements in this hash table. */ + size_t elements_with_deleted () const { return m_n_elements; } + /* This function clears all entries in the given hash table. */ + void empty (); -/* See if the table has been created, as opposed to constructed. */ + /* This function clears a specified SLOT in a hash table. It is + useful when you've already done the lookup and don't want to do it + again. */ -template <typename Descriptor, - template <typename Type> class Allocator> -inline bool -hash_table <Descriptor, Allocator>::is_created () -{ - return htab != NULL; -} + void clear_slot (value_type **); + /* This function searches for a hash table entry equal to the given + COMPARABLE element starting with the given HASH value. It cannot + be used to insert or delete an element. */ + value_type *find_with_hash (const compare_type *, hashval_t); -/* Like find_with_hash, but compute the hash value from the element. */ +/* Like find_slot_with_hash, but compute the hash value from the element. */ + value_type *find (const value_type *value) + { + return find_with_hash (value, Descriptor::hash (value)); + } -template <typename Descriptor, - template <typename Type> class Allocator> -inline typename Descriptor::value_type * -hash_table <Descriptor, Allocator>::find (const value_type *value) -{ - return find_with_hash (value, Descriptor::hash (value)); -} + value_type **find_slot (const value_type *value, insert_option insert) + { + return find_slot_with_hash (value, Descriptor::hash (value), insert); + } + /* This function searches for a hash table slot containing an entry + equal to the given COMPARABLE element and starting with the given + HASH. To delete an entry, call this with insert=NO_INSERT, then + call clear_slot on the slot returned (possibly after doing some + checks). To insert an entry, call this with insert=INSERT, then + write the value you want into the returned slot. When inserting an + entry, NULL may be returned if memory allocation fails. */ + value_type **find_slot_with_hash (const compare_type *comparable, + hashval_t hash, enum insert_option insert); -/* Like find_slot_with_hash, but compute the hash value from the element. */ + /* This function deletes an element with the given COMPARABLE value + from hash table starting with the given HASH. If there is no + matching element in the hash table, this function does nothing. */ + void remove_elt_with_hash (const compare_type *, hashval_t); -template <typename Descriptor, - template <typename Type> class Allocator> -inline typename Descriptor::value_type ** -hash_table <Descriptor, Allocator> -::find_slot (const value_type *value, enum insert_option insert) -{ - return find_slot_with_hash (value, Descriptor::hash (value), insert); -} +/* Like remove_elt_with_hash, but compute the hash value from the element. */ + void remove_elt (const value_type *value) + { + remove_elt_with_hash (value, Descriptor::hash (value)); + } + /* This function scans over the entire hash table calling CALLBACK for + each live entry. If CALLBACK returns false, the iteration stops. + ARGUMENT is passed as CALLBACK's second argument. */ + template <typename Argument, + int (*Callback) (value_type **slot, Argument argument)> + void traverse_noresize (Argument argument); -/* Like remove_elt_with_hash, but compute the hash value from the element. */ + /* Like traverse_noresize, but does resize the table when it is too empty + to improve effectivity of subsequent calls. */ + template <typename Argument, + int (*Callback) (value_type **slot, Argument argument)> + void traverse (Argument argument); -template <typename Descriptor, - template <typename Type> class Allocator> -inline void -hash_table <Descriptor, Allocator>::remove_elt (const value_type *value) -{ - remove_elt_with_hash (value, Descriptor::hash (value)); -} + class iterator + { + public: + iterator () : m_slot (NULL), m_limit (NULL) {} + iterator (value_type **slot, value_type **limit) : + m_slot (slot), m_limit (limit) {} -/* Return the current size of this hash table. */ + inline value_type &operator * () { return **m_slot; } + void slide (); + inline iterator &operator ++ (); + bool operator != (const iterator &other) const + { + return m_slot != other.m_slot || m_limit != other.m_limit; + } -template <typename Descriptor, - template <typename Type> class Allocator> -inline size_t -hash_table <Descriptor, Allocator>::size () -{ - return htab->size; -} + private: + value_type **m_slot; + value_type **m_limit; + }; + iterator begin () const + { + iterator iter (m_entries, m_entries + m_size); + iter.slide (); + return iter; + } -/* Return the current number of elements in this hash table. */ + iterator end () const { return iterator (); } -template <typename Descriptor, - template <typename Type> class Allocator> -inline size_t -hash_table <Descriptor, Allocator>::elements () -{ - return htab->n_elements - htab->n_deleted; -} + double collisions () const + { + return m_searches ? static_cast <double> (m_collisions) / m_searches : 0; + } +private: -/* Return the current number of elements in this hash table. */ + value_type **find_empty_slot_for_expand (hashval_t); + void expand (); -template <typename Descriptor, - template <typename Type> class Allocator> -inline size_t -hash_table <Descriptor, Allocator>::elements_with_deleted () -{ - return htab->n_elements; -} + /* Table itself. */ + typename Descriptor::value_type **m_entries; + size_t m_size; - /* Return the fraction of fixed collisions during all work with given - hash table. */ + /* Current number of elements including also deleted elements. */ + size_t m_n_elements; -template <typename Descriptor, - template <typename Type> class Allocator> -inline double -hash_table <Descriptor, Allocator>::collisions () -{ - if (htab->searches == 0) - return 0.0; + /* Current number of deleted elements in the table. */ + size_t m_n_deleted; - return static_cast <double> (htab->collisions) / htab->searches; -} + /* The following member is used for debugging. Its value is number + of all calls of `htab_find_slot' for the hash table. */ + unsigned int m_searches; + /* The following member is used for debugging. Its value is number + of collisions fixed for time of work with the hash table. */ + unsigned int m_collisions; -/* Create a hash table with at least the given number of INITIAL_SLOTS. */ + /* Current size (in entries) of the hash table, as an index into the + table of primes. */ + unsigned int m_size_prime_index; +}; -template <typename Descriptor, - template <typename Type> class Allocator> -void -hash_table <Descriptor, Allocator>::create (size_t size) +template<typename Descriptor, template<typename Type> class Allocator> +hash_table<Descriptor, Allocator>::hash_table (size_t size) : + m_n_elements (0), m_n_deleted (0), m_searches (0), m_collisions (0) { unsigned int size_prime_index; size_prime_index = hash_table_higher_prime_index (size); size = prime_tab[size_prime_index].prime; - htab = Allocator <hash_table_control <value_type> > ::control_alloc (1); - gcc_assert (htab != NULL); - htab->entries = Allocator <value_type*> ::data_alloc (size); - gcc_assert (htab->entries != NULL); - htab->size = size; - htab->size_prime_index = size_prime_index; + m_entries = Allocator <value_type*> ::data_alloc (size); + gcc_assert (m_entries != NULL); + m_size = size; + m_size_prime_index = size_prime_index; } - -/* Dispose of a hash table. Free all memory and return this hash table to - the non-created state. Naturally the hash table must already exist. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -void -hash_table <Descriptor, Allocator>::dispose () +template<typename Descriptor, template<typename Type> class Allocator> +hash_table<Descriptor, Allocator>::~hash_table () { - size_t size = htab->size; - value_type **entries = htab->entries; + for (size_t i = m_size - 1; i < m_size; i--) + if (m_entries[i] != HTAB_EMPTY_ENTRY && m_entries[i] != HTAB_DELETED_ENTRY) + Descriptor::remove (m_entries[i]); - for (int i = size - 1; i >= 0; i--) - if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY) - Descriptor::remove (entries[i]); - - Allocator <value_type *> ::data_free (entries); - Allocator <hash_table_control <value_type> > ::control_free (htab); - htab = NULL; + Allocator <value_type *> ::data_free (m_entries); } - /* Similar to find_slot, but without several unwanted side effects: - Does not call equal when it finds an existing entry. - Does not change the count of elements/searches/collisions in the @@ -614,14 +516,13 @@ hash_table <Descriptor, Allocator>::dispose () This function also assumes there are no deleted entries in the table. HASH is the hash value for the element to be inserted. */ -template <typename Descriptor, - template <typename Type> class Allocator> +template<typename Descriptor, template<typename Type> class Allocator> typename Descriptor::value_type ** -hash_table <Descriptor, Allocator>::find_empty_slot_for_expand (hashval_t hash) +hash_table<Descriptor, Allocator>::find_empty_slot_for_expand (hashval_t hash) { - hashval_t index = hash_table_mod1 (hash, htab->size_prime_index); - size_t size = htab->size; - value_type **slot = htab->entries + index; + hashval_t index = hash_table_mod1 (hash, m_size_prime_index); + size_t size = m_size; + value_type **slot = m_entries + index; hashval_t hash2; if (*slot == HTAB_EMPTY_ENTRY) @@ -629,14 +530,14 @@ hash_table <Descriptor, Allocator>::find_empty_slot_for_expand (hashval_t hash) else if (*slot == HTAB_DELETED_ENTRY) abort (); - hash2 = hash_table_mod2 (hash, htab->size_prime_index); + hash2 = hash_table_mod2 (hash, m_size_prime_index); for (;;) { index += hash2; if (index >= size) index -= size; - slot = htab->entries + index; + slot = m_entries + index; if (*slot == HTAB_EMPTY_ENTRY) return slot; else if (*slot == HTAB_DELETED_ENTRY) @@ -644,7 +545,6 @@ hash_table <Descriptor, Allocator>::find_empty_slot_for_expand (hashval_t hash) } } - /* The following function changes size of memory allocated for the entries and repeatedly inserts the table elements. The occupancy of the table after the call will be about 50%. Naturally the hash @@ -652,26 +552,20 @@ hash_table <Descriptor, Allocator>::find_empty_slot_for_expand (hashval_t hash) table entries is changed. If memory allocation fails, this function will abort. */ -template <typename Descriptor, - template <typename Type> class Allocator> + template<typename Descriptor, template<typename Type> class Allocator> void -hash_table <Descriptor, Allocator>::expand () +hash_table<Descriptor, Allocator>::expand () { - value_type **oentries; - value_type **olimit; - value_type **p; - value_type **nentries; - size_t nsize, osize, elts; - unsigned int oindex, nindex; - - oentries = htab->entries; - oindex = htab->size_prime_index; - osize = htab->size; - olimit = oentries + osize; - elts = elements (); + value_type **oentries = m_entries; + unsigned int oindex = m_size_prime_index; + size_t osize = size (); + value_type **olimit = oentries + osize; + size_t elts = elements (); /* Resize only when table after removal of unused elements is either too full or too empty. */ + unsigned int nindex; + size_t nsize; if (elts * 2 > osize || (elts * 8 < osize && osize > 32)) { nindex = hash_table_higher_prime_index (elts * 2); @@ -683,15 +577,15 @@ hash_table <Descriptor, Allocator>::expand () nsize = osize; } - nentries = Allocator <value_type *> ::data_alloc (nsize); + value_type **nentries = Allocator <value_type *> ::data_alloc (nsize); gcc_assert (nentries != NULL); - htab->entries = nentries; - htab->size = nsize; - htab->size_prime_index = nindex; - htab->n_elements -= htab->n_deleted; - htab->n_deleted = 0; + m_entries = nentries; + m_size = nsize; + m_size_prime_index = nindex; + m_n_elements -= m_n_deleted; + m_n_deleted = 0; - p = oentries; + value_type **p = oentries; do { value_type *x = *p; @@ -710,39 +604,80 @@ hash_table <Descriptor, Allocator>::expand () Allocator <value_type *> ::data_free (oentries); } +template<typename Descriptor, template<typename Type> class Allocator> +void +hash_table<Descriptor, Allocator>::empty () +{ + size_t size = m_size; + value_type **entries = m_entries; + int i; + + for (i = size - 1; i >= 0; i--) + if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY) + Descriptor::remove (entries[i]); + + /* Instead of clearing megabyte, downsize the table. */ + if (size > 1024*1024 / sizeof (PTR)) + { + int nindex = hash_table_higher_prime_index (1024 / sizeof (PTR)); + int nsize = prime_tab[nindex].prime; + + Allocator <value_type *> ::data_free (m_entries); + m_entries = Allocator <value_type *> ::data_alloc (nsize); + m_size = nsize; + m_size_prime_index = nindex; + } + else + memset (entries, 0, size * sizeof (value_type *)); + m_n_deleted = 0; + m_n_elements = 0; +} + +/* This function clears a specified SLOT in a hash table. It is + useful when you've already done the lookup and don't want to do it + again. */ + +template<typename Descriptor, template<typename Type> class Allocator> +void +hash_table<Descriptor, Allocator>::clear_slot (value_type **slot) +{ + if (slot < m_entries || slot >= m_entries + size () + || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY) + abort (); + + Descriptor::remove (*slot); + + *slot = static_cast <value_type *> (HTAB_DELETED_ENTRY); + m_n_deleted++; +} /* This function searches for a hash table entry equal to the given COMPARABLE element starting with the given HASH value. It cannot be used to insert or delete an element. */ -template <typename Descriptor, - template <typename Type> class Allocator> +template<typename Descriptor, template<typename Type> class Allocator> typename Descriptor::value_type * -hash_table <Descriptor, Allocator> +hash_table<Descriptor, Allocator> ::find_with_hash (const compare_type *comparable, hashval_t hash) { - hashval_t index, hash2; - size_t size; - value_type *entry; + m_searches++; + size_t size = m_size; + hashval_t index = hash_table_mod1 (hash, m_size_prime_index); - htab->searches++; - size = htab->size; - index = hash_table_mod1 (hash, htab->size_prime_index); - - entry = htab->entries[index]; + value_type *entry = m_entries[index]; if (entry == HTAB_EMPTY_ENTRY || (entry != HTAB_DELETED_ENTRY && Descriptor::equal (entry, comparable))) return entry; - hash2 = hash_table_mod2 (hash, htab->size_prime_index); + hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index); for (;;) { - htab->collisions++; + m_collisions++; index += hash2; if (index >= size) index -= size; - entry = htab->entries[index]; + entry = m_entries[index]; if (entry == HTAB_EMPTY_ENTRY || (entry != HTAB_DELETED_ENTRY && Descriptor::equal (entry, comparable))) @@ -750,7 +685,6 @@ hash_table <Descriptor, Allocator> } } - /* This function searches for a hash table slot containing an entry equal to the given COMPARABLE element and starting with the given HASH. To delete an entry, call this with insert=NO_INSERT, then @@ -759,56 +693,46 @@ hash_table <Descriptor, Allocator> write the value you want into the returned slot. When inserting an entry, NULL may be returned if memory allocation fails. */ -template <typename Descriptor, - template <typename Type> class Allocator> +template<typename Descriptor, template<typename Type> class Allocator> typename Descriptor::value_type ** -hash_table <Descriptor, Allocator> +hash_table<Descriptor, Allocator> ::find_slot_with_hash (const compare_type *comparable, hashval_t hash, enum insert_option insert) { - value_type **first_deleted_slot; - hashval_t index, hash2; - size_t size; - value_type *entry; - - size = htab->size; - if (insert == INSERT && size * 3 <= htab->n_elements * 4) - { - expand (); - size = htab->size; - } - - index = hash_table_mod1 (hash, htab->size_prime_index); + if (insert == INSERT && m_size * 3 <= m_n_elements * 4) + expand (); - htab->searches++; - first_deleted_slot = NULL; + m_searches++; - entry = htab->entries[index]; + value_type **first_deleted_slot = NULL; + hashval_t index = hash_table_mod1 (hash, m_size_prime_index); + hashval_t hash2 = hash_table_mod2 (hash, m_size_prime_index); + value_type *entry = m_entries[index]; + size_t size = m_size; if (entry == HTAB_EMPTY_ENTRY) goto empty_entry; else if (entry == HTAB_DELETED_ENTRY) - first_deleted_slot = &htab->entries[index]; + first_deleted_slot = &m_entries[index]; else if (Descriptor::equal (entry, comparable)) - return &htab->entries[index]; + return &m_entries[index]; - hash2 = hash_table_mod2 (hash, htab->size_prime_index); for (;;) { - htab->collisions++; + m_collisions++; index += hash2; if (index >= size) index -= size; - entry = htab->entries[index]; + entry = m_entries[index]; if (entry == HTAB_EMPTY_ENTRY) goto empty_entry; else if (entry == HTAB_DELETED_ENTRY) { if (!first_deleted_slot) - first_deleted_slot = &htab->entries[index]; + first_deleted_slot = &m_entries[index]; } else if (Descriptor::equal (entry, comparable)) - return &htab->entries[index]; + return &m_entries[index]; } empty_entry: @@ -817,108 +741,47 @@ hash_table <Descriptor, Allocator> if (first_deleted_slot) { - htab->n_deleted--; + m_n_deleted--; *first_deleted_slot = static_cast <value_type *> (HTAB_EMPTY_ENTRY); return first_deleted_slot; } - htab->n_elements++; - return &htab->entries[index]; -} - - -/* This function clears all entries in the given hash table. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -void -hash_table <Descriptor, Allocator>::empty () -{ - size_t size = htab->size; - value_type **entries = htab->entries; - int i; - - for (i = size - 1; i >= 0; i--) - if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY) - Descriptor::remove (entries[i]); - - /* Instead of clearing megabyte, downsize the table. */ - if (size > 1024*1024 / sizeof (PTR)) - { - int nindex = hash_table_higher_prime_index (1024 / sizeof (PTR)); - int nsize = prime_tab[nindex].prime; - - Allocator <value_type *> ::data_free (htab->entries); - htab->entries = Allocator <value_type *> ::data_alloc (nsize); - htab->size = nsize; - htab->size_prime_index = nindex; - } - else - memset (entries, 0, size * sizeof (value_type *)); - htab->n_deleted = 0; - htab->n_elements = 0; -} - - -/* This function clears a specified SLOT in a hash table. It is - useful when you've already done the lookup and don't want to do it - again. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -void -hash_table <Descriptor, Allocator>::clear_slot (value_type **slot) -{ - if (slot < htab->entries || slot >= htab->entries + htab->size - || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY) - abort (); - - Descriptor::remove (*slot); - - *slot = static_cast <value_type *> (HTAB_DELETED_ENTRY); - htab->n_deleted++; + m_n_elements++; + return &m_entries[index]; } - /* This function deletes an element with the given COMPARABLE value from hash table starting with the given HASH. If there is no matching element in the hash table, this function does nothing. */ -template <typename Descriptor, - template <typename Type> class Allocator> +template<typename Descriptor, template<typename Type> class Allocator> void -hash_table <Descriptor, Allocator> +hash_table<Descriptor, Allocator> ::remove_elt_with_hash (const compare_type *comparable, hashval_t hash) { - value_type **slot; - - slot = find_slot_with_hash (comparable, hash, NO_INSERT); + value_type **slot = find_slot_with_hash (comparable, hash, NO_INSERT); if (*slot == HTAB_EMPTY_ENTRY) return; Descriptor::remove (*slot); *slot = static_cast <value_type *> (HTAB_DELETED_ENTRY); - htab->n_deleted++; + m_n_deleted++; } - /* This function scans over the entire hash table calling CALLBACK for each live entry. If CALLBACK returns false, the iteration stops. ARGUMENT is passed as CALLBACK's second argument. */ -template <typename Descriptor, - template <typename Type> class Allocator> -template <typename Argument, +template<typename Descriptor, + template<typename Type> class Allocator> +template<typename Argument, int (*Callback) (typename Descriptor::value_type **slot, Argument argument)> void -hash_table <Descriptor, Allocator>::traverse_noresize (Argument argument) +hash_table<Descriptor, Allocator>::traverse_noresize (Argument argument) { - value_type **slot; - value_type **limit; - - slot = htab->entries; - limit = slot + htab->size; + value_type **slot = m_entries; + value_type **limit = slot + size (); do { @@ -931,7 +794,6 @@ hash_table <Descriptor, Allocator>::traverse_noresize (Argument argument) while (++slot < limit); } - /* Like traverse_noresize, but does resize the table when it is too empty to improve effectivity of subsequent calls. */ @@ -941,55 +803,20 @@ template <typename Argument, int (*Callback) (typename Descriptor::value_type **slot, Argument argument)> void -hash_table <Descriptor, Allocator>::traverse (Argument argument) +hash_table<Descriptor, Allocator>::traverse (Argument argument) { - size_t size = htab->size; + size_t size = m_size; if (elements () * 8 < size && size > 32) expand (); traverse_noresize <Argument, Callback> (argument); } - -/* Iterator definitions. */ - -/* The default constructor produces the end value. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -inline -hash_table <Descriptor, Allocator>::iterator::iterator () -: m_slot (NULL), m_limit (NULL) -{ -} - -/* The parameterized constructor produces the begin value. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -inline -hash_table <Descriptor, Allocator>::iterator::iterator - (value_type **slot, value_type **limit) -: m_slot (slot), m_limit (limit) -{ -} - -/* Obtain the element. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -inline typename hash_table <Descriptor, Allocator>::value_type & -hash_table <Descriptor, Allocator>::iterator::operator * () -{ - return **m_slot; -} - /* Slide down the iterator slots until an active entry is found. */ -template <typename Descriptor, - template <typename Type> class Allocator> +template<typename Descriptor, template<typename Type> class Allocator> void -hash_table <Descriptor, Allocator>::iterator::slide () +hash_table<Descriptor, Allocator>::iterator::slide () { for ( ; m_slot < m_limit; ++m_slot ) { @@ -1003,50 +830,15 @@ hash_table <Descriptor, Allocator>::iterator::slide () /* Bump the iterator. */ -template <typename Descriptor, - template <typename Type> class Allocator> -inline typename hash_table <Descriptor, Allocator>::iterator & -hash_table <Descriptor, Allocator>::iterator::operator ++ () +template<typename Descriptor, template<typename Type> class Allocator> +inline typename hash_table<Descriptor, Allocator>::iterator & +hash_table<Descriptor, Allocator>::iterator::operator ++ () { ++m_slot; slide (); return *this; } -/* Compare iterators. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -inline bool -hash_table <Descriptor, Allocator>::iterator:: - operator != (const iterator &other) const -{ - return m_slot != other.m_slot || m_limit != other.m_limit; -} - -/* Hash table iterator producers. */ - -/* The beginning of a hash table iteration. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -inline typename hash_table <Descriptor, Allocator>::iterator -hash_table <Descriptor, Allocator>::begin () -{ - iterator hti (htab->entries, htab->entries + htab->size); - hti.slide (); - return hti; -} - -/* The end of a hash table iteration. */ - -template <typename Descriptor, - template <typename Type> class Allocator> -inline typename hash_table <Descriptor, Allocator>::iterator -hash_table <Descriptor, Allocator>::end () -{ - return iterator (); -} /* Iterate through the elements of hash_table HTAB, using hash_table <....>::iterator ITER, diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c index a90d1dcd736..604b809dbcd 100644 --- a/gcc/ipa-devirt.c +++ b/gcc/ipa-devirt.c @@ -324,8 +324,8 @@ odr_hasher::remove (value_type *v) /* ODR type hash used to lookup ODR type based on tree type node. */ -typedef hash_table <odr_hasher> odr_hash_type; -static odr_hash_type odr_hash; +typedef hash_table<odr_hasher> odr_hash_type; +static odr_hash_type *odr_hash; /* ODR types are also stored into ODR_TYPE vector to allow consistent walking. Bases appear before derived types. Vector is garbage collected @@ -473,7 +473,8 @@ get_odr_type (tree type, bool insert) type = TYPE_MAIN_VARIANT (type); gcc_checking_assert (TYPE_MAIN_VARIANT (type) == type); hash = hash_type_name (type); - slot = odr_hash.find_slot_with_hash (type, hash, insert ? INSERT : NO_INSERT); + slot + = odr_hash->find_slot_with_hash (type, hash, insert ? INSERT : NO_INSERT); if (!slot) return NULL; @@ -611,11 +612,11 @@ build_type_inheritance_graph (void) FILE *inheritance_dump_file; int flags; - if (odr_hash.is_created ()) + if (odr_hash) return; timevar_push (TV_IPA_INHERITANCE); inheritance_dump_file = dump_begin (TDI_inheritance, &flags); - odr_hash.create (23); + odr_hash = new odr_hash_type (23); /* We reconstruct the graph starting of types of all methods seen in the the unit. */ @@ -1011,9 +1012,9 @@ polymorphic_call_target_hasher::remove (value_type *v) /* Polymorphic call target query cache. */ -typedef hash_table <polymorphic_call_target_hasher> +typedef hash_table<polymorphic_call_target_hasher> polymorphic_call_target_hash_type; -static polymorphic_call_target_hash_type polymorphic_call_target_hash; +static polymorphic_call_target_hash_type *polymorphic_call_target_hash; /* Destroy polymorphic call target query cache. */ @@ -1022,7 +1023,8 @@ free_polymorphic_call_targets_hash () { if (cached_polymorphic_call_targets) { - polymorphic_call_target_hash.dispose (); + delete polymorphic_call_target_hash; + polymorphic_call_target_hash = NULL; pointer_set_destroy (cached_polymorphic_call_targets); cached_polymorphic_call_targets = NULL; } @@ -1599,7 +1601,7 @@ possible_polymorphic_call_targets (tree otr_type, bool skipped = false; /* If ODR is not initialized, return empty incomplete list. */ - if (!odr_hash.is_created ()) + if (!odr_hash) { if (completep) *completep = false; @@ -1656,7 +1658,8 @@ possible_polymorphic_call_targets (tree otr_type, if (!cached_polymorphic_call_targets) { cached_polymorphic_call_targets = pointer_set_create (); - polymorphic_call_target_hash.create (23); + polymorphic_call_target_hash + = new polymorphic_call_target_hash_type (23); if (!node_removal_hook_holder) { node_removal_hook_holder = @@ -1670,7 +1673,7 @@ possible_polymorphic_call_targets (tree otr_type, key.type = type; key.otr_token = otr_token; key.context = context; - slot = polymorphic_call_target_hash.find_slot (&key, INSERT); + slot = polymorphic_call_target_hash->find_slot (&key, INSERT); if (cache_token) *cache_token = (void *)*slot; if (*slot) @@ -1865,7 +1868,7 @@ possible_polymorphic_call_target_p (tree otr_type, || fcode == BUILT_IN_TRAP)) return true; - if (!odr_hash.is_created ()) + if (!odr_hash) return true; targets = possible_polymorphic_call_targets (otr_type, otr_token, ctx, &final); for (i = 0; i < targets.length (); i++) @@ -1888,7 +1891,7 @@ update_type_inheritance_graph (void) { struct cgraph_node *n; - if (!odr_hash.is_created ()) + if (!odr_hash) return; free_polymorphic_call_targets_hash (); timevar_push (TV_IPA_INHERITANCE); diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c index 339f38ea0db..625d49cbbb9 100644 --- a/gcc/ipa-profile.c +++ b/gcc/ipa-profile.c @@ -112,12 +112,12 @@ histogram_hash::equal (const histogram_entry *val, const histogram_entry *val2) HASHTABLE is the on-side hash kept to avoid duplicates. */ static void -account_time_size (hash_table <histogram_hash> hashtable, +account_time_size (hash_table<histogram_hash> *hashtable, vec<histogram_entry *> &histogram, gcov_type count, int time, int size) { histogram_entry key = {count, 0, 0}; - histogram_entry **val = hashtable.find_slot (&key, INSERT); + histogram_entry **val = hashtable->find_slot (&key, INSERT); if (!*val) { @@ -179,10 +179,9 @@ ipa_profile_generate_summary (void) { struct cgraph_node *node; gimple_stmt_iterator gsi; - hash_table <histogram_hash> hashtable; basic_block bb; - hashtable.create (10); + hash_table<histogram_hash> hashtable (10); histogram_pool = create_alloc_pool ("IPA histogram", sizeof (struct histogram_entry), 10); @@ -230,9 +229,8 @@ ipa_profile_generate_summary (void) time += estimate_num_insns (stmt, &eni_time_weights); size += estimate_num_insns (stmt, &eni_size_weights); } - account_time_size (hashtable, histogram, bb->count, time, size); + account_time_size (&hashtable, histogram, bb->count, time, size); } - hashtable.dispose (); histogram.qsort (cmp_counts); } @@ -263,10 +261,9 @@ ipa_profile_read_summary (void) struct lto_file_decl_data ** file_data_vec = lto_get_file_decl_data (); struct lto_file_decl_data * file_data; - hash_table <histogram_hash> hashtable; int j = 0; - hashtable.create (10); + hash_table<histogram_hash> hashtable (10); histogram_pool = create_alloc_pool ("IPA histogram", sizeof (struct histogram_entry), 10); @@ -287,7 +284,7 @@ ipa_profile_read_summary (void) gcov_type count = streamer_read_gcov_count (ib); int time = streamer_read_uhwi (ib); int size = streamer_read_uhwi (ib); - account_time_size (hashtable, histogram, + account_time_size (&hashtable, histogram, count, time, size); } lto_destroy_simple_input_block (file_data, @@ -295,7 +292,6 @@ ipa_profile_read_summary (void) ib, data, len); } } - hashtable.dispose (); histogram.qsort (cmp_counts); } diff --git a/gcc/ira-color.c b/gcc/ira-color.c index 36e7e879952..36c3c879f57 100644 --- a/gcc/ira-color.c +++ b/gcc/ira-color.c @@ -222,13 +222,13 @@ allocno_hard_regs_hasher::equal (const value_type *hv1, const compare_type *hv2) } /* Hash table of unique allocno hard registers. */ -static hash_table <allocno_hard_regs_hasher> allocno_hard_regs_htab; +static hash_table<allocno_hard_regs_hasher> *allocno_hard_regs_htab; /* Return allocno hard registers in the hash table equal to HV. */ static allocno_hard_regs_t find_hard_regs (allocno_hard_regs_t hv) { - return allocno_hard_regs_htab.find (hv); + return allocno_hard_regs_htab->find (hv); } /* Insert allocno hard registers HV in the hash table (if it is not @@ -236,7 +236,7 @@ find_hard_regs (allocno_hard_regs_t hv) static allocno_hard_regs_t insert_hard_regs (allocno_hard_regs_t hv) { - allocno_hard_regs **slot = allocno_hard_regs_htab.find_slot (hv, INSERT); + allocno_hard_regs **slot = allocno_hard_regs_htab->find_slot (hv, INSERT); if (*slot == NULL) *slot = hv; @@ -248,7 +248,8 @@ static void init_allocno_hard_regs (void) { allocno_hard_regs_vec.create (200); - allocno_hard_regs_htab.create (200); + allocno_hard_regs_htab + = new hash_table<allocno_hard_regs_hasher> (200); } /* Add (or update info about) allocno hard registers with SET and @@ -286,7 +287,8 @@ finish_allocno_hard_regs (void) allocno_hard_regs_vec.iterate (i, &hv); i++) ira_free (hv); - allocno_hard_regs_htab.dispose (); + delete allocno_hard_regs_htab; + allocno_hard_regs_htab = NULL; allocno_hard_regs_vec.release (); } diff --git a/gcc/ira-costs.c b/gcc/ira-costs.c index 5716c2a22d9..a83e1dff00c 100644 --- a/gcc/ira-costs.c +++ b/gcc/ira-costs.c @@ -167,7 +167,7 @@ cost_classes_hasher::remove (value_type *v) } /* Hash table of unique cost classes. */ -static hash_table <cost_classes_hasher> cost_classes_htab; +static hash_table<cost_classes_hasher> *cost_classes_htab; /* Map allocno class -> cost classes for pseudo of given allocno class. */ @@ -188,7 +188,7 @@ initiate_regno_cost_classes (void) sizeof (cost_classes_t) * N_REG_CLASSES); memset (cost_classes_mode_cache, 0, sizeof (cost_classes_t) * MAX_MACHINE_MODE); - cost_classes_htab.create (200); + cost_classes_htab = new hash_table<cost_classes_hasher> (200); } /* Create new cost classes from cost classes FROM and set up members @@ -262,7 +262,7 @@ setup_regno_cost_classes_by_aclass (int regno, enum reg_class aclass) } classes.classes[classes.num++] = cl; } - slot = cost_classes_htab.find_slot (&classes, INSERT); + slot = cost_classes_htab->find_slot (&classes, INSERT); if (*slot == NULL) { classes_ptr = setup_cost_classes (&classes); @@ -301,7 +301,7 @@ setup_regno_cost_classes_by_mode (int regno, enum machine_mode mode) continue; classes.classes[classes.num++] = cl; } - slot = cost_classes_htab.find_slot (&classes, INSERT); + slot = cost_classes_htab->find_slot (&classes, INSERT); if (*slot == NULL) { classes_ptr = setup_cost_classes (&classes); @@ -319,7 +319,8 @@ static void finish_regno_cost_classes (void) { ira_free (regno_cost_classes); - cost_classes_htab.dispose (); + delete cost_classes_htab; + cost_classes_htab = NULL; } diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog index 09e7978d942..ce90e28f791 100644 --- a/gcc/java/ChangeLog +++ b/gcc/java/ChangeLog @@ -1,3 +1,7 @@ +2014-06-24 Trevor Saunders <tsaunders@mozilla.com> + + * jcf-io.c: Adjust. + 2014-06-11 Jan Hubicka <hubicka@ucw.cz> * java/class.c (build_utf8_ref): Update handling for section names diff --git a/gcc/java/jcf-io.c b/gcc/java/jcf-io.c index 7491882254d..358fc1e47c1 100644 --- a/gcc/java/jcf-io.c +++ b/gcc/java/jcf-io.c @@ -299,7 +299,7 @@ charstar_hash::equal (const value_type *existing, const compare_type *candidate) during class lookup. (There is no need to cache the values associated with names that were found; they are saved in IDENTIFIER_CLASS_VALUE.) */ -static hash_table <charstar_hash> memoized_class_lookups; +static hash_table<charstar_hash> *memoized_class_lookups; /* Returns a freshly malloc'd string with the fully qualified pathname of the .class file for the class CLASSNAME. CLASSNAME must be @@ -321,13 +321,13 @@ find_class (const char *classname, int classname_length, JCF *jcf) hashval_t hash; /* Create the hash table, if it does not already exist. */ - if (!memoized_class_lookups.is_created ()) - memoized_class_lookups.create (37); + if (!memoized_class_lookups) + memoized_class_lookups = new hash_table<charstar_hash> (37); /* Loop for this class in the hashtable. If it is present, we've already looked for this class and failed to find it. */ hash = charstar_hash::hash (classname); - if (memoized_class_lookups.find_with_hash (classname, hash)) + if (memoized_class_lookups->find_with_hash (classname, hash)) return NULL; /* Allocate and zero out the buffer, since we don't explicitly put a @@ -402,7 +402,7 @@ find_class (const char *classname, int classname_length, JCF *jcf) /* Remember that this class could not be found so that we do not have to look again. */ - *memoized_class_lookups.find_slot_with_hash (classname, hash, INSERT) + *memoized_class_lookups->find_slot_with_hash (classname, hash, INSERT) = classname; return NULL; diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c index 25e63e44272..3852c6b91b4 100644 --- a/gcc/loop-invariant.c +++ b/gcc/loop-invariant.c @@ -453,14 +453,14 @@ invariant_expr_hasher::equal (const value_type *entry1, entry2->inv->insn, entry2->expr); } -typedef hash_table <invariant_expr_hasher> invariant_htab_type; +typedef hash_table<invariant_expr_hasher> invariant_htab_type; /* Checks whether invariant with value EXPR in machine mode MODE is recorded in EQ. If this is the case, return the invariant. Otherwise insert INV to the table for this expression and return INV. */ static struct invariant * -find_or_insert_inv (invariant_htab_type eq, rtx expr, enum machine_mode mode, +find_or_insert_inv (invariant_htab_type *eq, rtx expr, enum machine_mode mode, struct invariant *inv) { hashval_t hash = hash_invariant_expr_1 (inv->insn, expr); @@ -471,7 +471,7 @@ find_or_insert_inv (invariant_htab_type eq, rtx expr, enum machine_mode mode, pentry.expr = expr; pentry.inv = inv; pentry.mode = mode; - slot = eq.find_slot_with_hash (&pentry, hash, INSERT); + slot = eq->find_slot_with_hash (&pentry, hash, INSERT); entry = *slot; if (entry) @@ -491,7 +491,7 @@ find_or_insert_inv (invariant_htab_type eq, rtx expr, enum machine_mode mode, hash table of the invariants. */ static void -find_identical_invariants (invariant_htab_type eq, struct invariant *inv) +find_identical_invariants (invariant_htab_type *eq, struct invariant *inv) { unsigned depno; bitmap_iterator bi; @@ -528,13 +528,10 @@ merge_identical_invariants (void) { unsigned i; struct invariant *inv; - invariant_htab_type eq; - eq.create (invariants.length ()); + invariant_htab_type eq (invariants.length ()); FOR_EACH_VEC_ELT (invariants, i, inv) - find_identical_invariants (eq, inv); - - eq.dispose (); + find_identical_invariants (&eq, inv); } /* Determines the basic blocks inside LOOP that are always executed and diff --git a/gcc/loop-iv.c b/gcc/loop-iv.c index ee6c71e8a47..1c204e9c1da 100644 --- a/gcc/loop-iv.c +++ b/gcc/loop-iv.c @@ -134,7 +134,7 @@ biv_entry_hasher::equal (const value_type *b, const compare_type *r) /* Bivs of the current loop. */ -static hash_table <biv_entry_hasher> bivs; +static hash_table<biv_entry_hasher> *bivs; static bool iv_analyze_op (rtx, rtx, struct rtx_iv *); @@ -269,7 +269,7 @@ clear_iv_info (void) } } - bivs.empty (); + bivs->empty (); } @@ -284,7 +284,7 @@ iv_analysis_loop_init (struct loop *loop) if (clean_slate) { df_set_flags (DF_EQ_NOTES + DF_DEFER_INSN_RESCAN); - bivs.create (10); + bivs = new hash_table<biv_entry_hasher> (10); clean_slate = false; } else @@ -844,7 +844,7 @@ record_iv (df_ref def, struct rtx_iv *iv) static bool analyzed_for_bivness_p (rtx def, struct rtx_iv *iv) { - struct biv_entry *biv = bivs.find_with_hash (def, REGNO (def)); + struct biv_entry *biv = bivs->find_with_hash (def, REGNO (def)); if (!biv) return false; @@ -857,7 +857,7 @@ static void record_biv (rtx def, struct rtx_iv *iv) { struct biv_entry *biv = XNEW (struct biv_entry); - biv_entry **slot = bivs.find_slot_with_hash (def, REGNO (def), INSERT); + biv_entry **slot = bivs->find_slot_with_hash (def, REGNO (def), INSERT); biv->regno = REGNO (def); biv->iv = *iv; @@ -1299,7 +1299,8 @@ iv_analysis_done (void) clear_iv_info (); clean_slate = true; df_finish_pass (true); - bivs.dispose (); + delete bivs; + bivs = NULL; free (iv_ref_table); iv_ref_table = NULL; iv_ref_table_size = 0; diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c index 4ce0830c4ca..ad4d3c2da50 100644 --- a/gcc/loop-unroll.c +++ b/gcc/loop-unroll.c @@ -161,11 +161,11 @@ var_expand_hasher::equal (const value_type *i1, const compare_type *i2) struct opt_info { - hash_table <iv_split_hasher> insns_to_split; /* A hashtable of insns to + hash_table<iv_split_hasher> *insns_to_split; /* A hashtable of insns to split. */ struct iv_to_split *iv_to_split_head; /* The first iv to split. */ struct iv_to_split **iv_to_split_tail; /* Pointer to the tail of the list. */ - hash_table <var_expand_hasher> insns_with_var_to_expand; /* A hashtable of + hash_table<var_expand_hasher> *insns_with_var_to_expand; /* A hashtable of insns with accumulators to expand. */ struct var_to_expand *var_to_expand_head; /* The first var to expand. */ struct var_to_expand **var_to_expand_tail; /* Pointer to the tail of the list. */ @@ -1974,7 +1974,8 @@ analyze_insns_in_loop (struct loop *loop) if (flag_split_ivs_in_unroller) { - opt_info->insns_to_split.create (5 * loop->num_nodes); + opt_info->insns_to_split + = new hash_table<iv_split_hasher> (5 * loop->num_nodes); opt_info->iv_to_split_head = NULL; opt_info->iv_to_split_tail = &opt_info->iv_to_split_head; } @@ -1995,7 +1996,8 @@ analyze_insns_in_loop (struct loop *loop) if (flag_variable_expansion_in_unroller && can_apply) { - opt_info->insns_with_var_to_expand.create (5 * loop->num_nodes); + opt_info->insns_with_var_to_expand + = new hash_table<var_expand_hasher> (5 * loop->num_nodes); opt_info->var_to_expand_head = NULL; opt_info->var_to_expand_tail = &opt_info->var_to_expand_head; } @@ -2011,12 +2013,12 @@ analyze_insns_in_loop (struct loop *loop) if (!INSN_P (insn)) continue; - if (opt_info->insns_to_split.is_created ()) + if (opt_info->insns_to_split) ivts = analyze_iv_to_split_insn (insn); if (ivts) { - slot1 = opt_info->insns_to_split.find_slot (ivts, INSERT); + slot1 = opt_info->insns_to_split->find_slot (ivts, INSERT); gcc_assert (*slot1 == NULL); *slot1 = ivts; *opt_info->iv_to_split_tail = ivts; @@ -2024,12 +2026,12 @@ analyze_insns_in_loop (struct loop *loop) continue; } - if (opt_info->insns_with_var_to_expand.is_created ()) + if (opt_info->insns_with_var_to_expand) ves = analyze_insn_to_expand_var (loop, insn); if (ves) { - slot2 = opt_info->insns_with_var_to_expand.find_slot (ves, INSERT); + slot2 = opt_info->insns_with_var_to_expand->find_slot (ves, INSERT); gcc_assert (*slot2 == NULL); *slot2 = ves; *opt_info->var_to_expand_tail = ves; @@ -2407,7 +2409,7 @@ apply_opt_in_copies (struct opt_info *opt_info, gcc_assert (!unrolling || rewrite_original_loop); /* Allocate the basic variables (i0). */ - if (opt_info->insns_to_split.is_created ()) + if (opt_info->insns_to_split) for (ivts = opt_info->iv_to_split_head; ivts; ivts = ivts->next) allocate_basic_variable (ivts); @@ -2441,11 +2443,11 @@ apply_opt_in_copies (struct opt_info *opt_info, ve_templ.insn = orig_insn; /* Apply splitting iv optimization. */ - if (opt_info->insns_to_split.is_created ()) + if (opt_info->insns_to_split) { maybe_strip_eq_note_for_split_iv (opt_info, insn); - ivts = opt_info->insns_to_split.find (&ivts_templ); + ivts = opt_info->insns_to_split->find (&ivts_templ); if (ivts) { @@ -2458,10 +2460,10 @@ apply_opt_in_copies (struct opt_info *opt_info, } } /* Apply variable expansion optimization. */ - if (unrolling && opt_info->insns_with_var_to_expand.is_created ()) + if (unrolling && opt_info->insns_with_var_to_expand) { ves = (struct var_to_expand *) - opt_info->insns_with_var_to_expand.find (&ve_templ); + opt_info->insns_with_var_to_expand->find (&ve_templ); if (ves) { gcc_assert (GET_CODE (PATTERN (insn)) @@ -2478,7 +2480,7 @@ apply_opt_in_copies (struct opt_info *opt_info, /* Initialize the variable expansions in the loop preheader and take care of combining them at the loop exit. */ - if (opt_info->insns_with_var_to_expand.is_created ()) + if (opt_info->insns_with_var_to_expand) { for (ves = opt_info->var_to_expand_head; ves; ves = ves->next) insert_var_expansion_initialization (ves, opt_info->loop_preheader); @@ -2509,12 +2511,12 @@ apply_opt_in_copies (struct opt_info *opt_info, continue; ivts_templ.insn = orig_insn; - if (opt_info->insns_to_split.is_created ()) + if (opt_info->insns_to_split) { maybe_strip_eq_note_for_split_iv (opt_info, orig_insn); ivts = (struct iv_to_split *) - opt_info->insns_to_split.find (&ivts_templ); + opt_info->insns_to_split->find (&ivts_templ); if (ivts) { if (!delta) @@ -2533,15 +2535,16 @@ apply_opt_in_copies (struct opt_info *opt_info, static void free_opt_info (struct opt_info *opt_info) { - if (opt_info->insns_to_split.is_created ()) - opt_info->insns_to_split.dispose (); - if (opt_info->insns_with_var_to_expand.is_created ()) + delete opt_info->insns_to_split; + opt_info->insns_to_split = NULL; + if (opt_info->insns_with_var_to_expand) { struct var_to_expand *ves; for (ves = opt_info->var_to_expand_head; ves; ves = ves->next) ves->var_expansions.release (); - opt_info->insns_with_var_to_expand.dispose (); + delete opt_info->insns_with_var_to_expand; + opt_info->insns_with_var_to_expand = NULL; } free (opt_info); } diff --git a/gcc/lto-streamer-in.c b/gcc/lto-streamer-in.c index a18c64e060d..671532715a5 100644 --- a/gcc/lto-streamer-in.c +++ b/gcc/lto-streamer-in.c @@ -72,7 +72,7 @@ freeing_string_slot_hasher::remove (value_type *v) } /* The table to hold the file names. */ -static hash_table <freeing_string_slot_hasher> file_name_hash_table; +static hash_table<freeing_string_slot_hasher> *file_name_hash_table; /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the @@ -123,7 +123,7 @@ canon_file_name (const char *string) s_slot.s = string; s_slot.len = len; - slot = file_name_hash_table.find_slot (&s_slot, INSERT); + slot = file_name_hash_table->find_slot (&s_slot, INSERT); if (*slot == NULL) { char *saved_string; @@ -1363,7 +1363,8 @@ void lto_reader_init (void) { lto_streamer_init (); - file_name_hash_table.create (37); + file_name_hash_table + = new hash_table<freeing_string_slot_hasher> (37); } diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c index 05b2384a228..3af53735d52 100644 --- a/gcc/lto-streamer-out.c +++ b/gcc/lto-streamer-out.c @@ -87,7 +87,7 @@ create_output_block (enum lto_section_type section_type) clear_line_info (ob); - ob->string_hash_table.create (37); + ob->string_hash_table = new hash_table<string_slot_hasher> (37); gcc_obstack_init (&ob->obstack); return ob; @@ -101,7 +101,8 @@ destroy_output_block (struct output_block *ob) { enum lto_section_type section_type = ob->section_type; - ob->string_hash_table.dispose (); + delete ob->string_hash_table; + ob->string_hash_table = NULL; free (ob->main_stream); free (ob->string_stream); diff --git a/gcc/lto-streamer.c b/gcc/lto-streamer.c index a352adfe948..34807231bc8 100644 --- a/gcc/lto-streamer.c +++ b/gcc/lto-streamer.c @@ -290,7 +290,7 @@ tree_entry_hasher::equal (const value_type *e1, const compare_type *e2) return (e1->key == e2->key); } -static hash_table <tree_hash_entry> tree_htab; +static hash_table<tree_hash_entry> *tree_htab; #endif /* Initialization common to the LTO reader and writer. */ @@ -305,7 +305,7 @@ lto_streamer_init (void) streamer_check_handled_ts_structures (); #ifdef LTO_STREAMER_DEBUG - tree_htab.create (31); + tree_htab = new hash_table<tree_hash_entry> (31); #endif } @@ -340,7 +340,7 @@ lto_orig_address_map (tree t, intptr_t orig_t) ent.key = t; ent.value = orig_t; - slot = tree_htab.find_slot (&ent, INSERT); + slot = tree_htab->find_slot (&ent, INSERT); gcc_assert (!*slot); *slot = XNEW (struct tree_hash_entry); **slot = ent; @@ -357,7 +357,7 @@ lto_orig_address_get (tree t) struct tree_hash_entry **slot; ent.key = t; - slot = tree_htab.find_slot (&ent, NO_INSERT); + slot = tree_htab->find_slot (&ent, NO_INSERT); return (slot ? (*slot)->value : 0); } @@ -371,10 +371,10 @@ lto_orig_address_remove (tree t) struct tree_hash_entry **slot; ent.key = t; - slot = tree_htab.find_slot (&ent, NO_INSERT); + slot = tree_htab->find_slot (&ent, NO_INSERT); gcc_assert (slot); free (*slot); - tree_htab.clear_slot (slot); + tree_htab->clear_slot (slot); } #endif diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h index 521d78dacc9..889e91dbc25 100644 --- a/gcc/lto-streamer.h +++ b/gcc/lto-streamer.h @@ -682,7 +682,7 @@ struct output_block /* The hash table that contains the set of strings we have seen so far and the indexes assigned to them. */ - hash_table <string_slot_hasher> string_hash_table; + hash_table<string_slot_hasher> *string_hash_table; /* The current cgraph_node that we are currently serializing. Null if we are serializing something else. */ diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog index 4086b2134eb..29d7a5bff71 100644 --- a/gcc/lto/ChangeLog +++ b/gcc/lto/ChangeLog @@ -1,3 +1,7 @@ +2014-06-24 Trevor Saunders <tsaunders@mozilla.com> + + * lto.c: Adjust. + 2014-06-20 Jan Hubicka <hubicka@ucw.cz> * lto-symtab.c (lto_varpool_replace_node): Report TLS model conflicts. diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c index 9cee3701e05..1fe7ce4eefb 100644 --- a/gcc/lto/lto.c +++ b/gcc/lto/lto.c @@ -1137,7 +1137,7 @@ tree_scc_hasher::equal (const value_type *scc1, const compare_type *scc2) return true; } -static hash_table <tree_scc_hasher> tree_scc_hash; +static hash_table<tree_scc_hasher> *tree_scc_hash; static struct obstack tree_scc_hash_obstack; static unsigned long num_merged_types; @@ -1734,7 +1734,7 @@ unify_scc (struct streamer_tree_cache_d *cache, unsigned from, /* Look for the list of candidate SCCs to compare against. */ tree_scc **slot; - slot = tree_scc_hash.find_slot_with_hash (scc, scc_hash, INSERT); + slot = tree_scc_hash->find_slot_with_hash (scc, scc_hash, INSERT); if (*slot) { /* Try unifying against each candidate. */ @@ -2921,7 +2921,7 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) gimple_canonical_types = htab_create_ggc (16381, gimple_canonical_type_hash, gimple_canonical_type_eq, 0); gcc_obstack_init (&tree_scc_hash_obstack); - tree_scc_hash.create (4096); + tree_scc_hash = new hash_table<tree_scc_hasher> (4096); /* Register the common node types with the canonical type machinery so we properly share alias-sets across languages and TUs. Do not @@ -2987,7 +2987,8 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) print_lto_report_1 (); /* Free gimple type merging datastructures. */ - tree_scc_hash.dispose (); + delete tree_scc_hash; + tree_scc_hash = NULL; obstack_free (&tree_scc_hash_obstack, NULL); htab_delete (gimple_canonical_types); gimple_canonical_types = NULL; @@ -3159,17 +3160,17 @@ print_lto_report_1 (void) fprintf (stderr, "[%s] read %lu SCCs of average size %f\n", pfx, num_sccs_read, total_scc_size / (double)num_sccs_read); fprintf (stderr, "[%s] %lu tree bodies read in total\n", pfx, total_scc_size); - if (flag_wpa && tree_scc_hash.is_created ()) + if (flag_wpa && tree_scc_hash) { fprintf (stderr, "[%s] tree SCC table: size %ld, %ld elements, " "collision ratio: %f\n", pfx, - (long) tree_scc_hash.size (), - (long) tree_scc_hash.elements (), - tree_scc_hash.collisions ()); + (long) tree_scc_hash->size (), + (long) tree_scc_hash->elements (), + tree_scc_hash->collisions ()); hash_table<tree_scc_hasher>::iterator hiter; tree_scc *scc, *max_scc = NULL; unsigned max_length = 0; - FOR_EACH_HASH_TABLE_ELEMENT (tree_scc_hash, scc, x, hiter) + FOR_EACH_HASH_TABLE_ELEMENT (*tree_scc_hash, scc, x, hiter) { unsigned length = 0; tree_scc *s = scc; diff --git a/gcc/objc/ChangeLog b/gcc/objc/ChangeLog index 73a41b6bcea..dfd8f387e06 100644 --- a/gcc/objc/ChangeLog +++ b/gcc/objc/ChangeLog @@ -1,3 +1,7 @@ +2014-06-24 Trevor Saunders <tsaunders@mozilla.com> + + * objc-act.c: Adjust. + 2014-05-17 Trevor Saunders <tsaunders@mozilla.com> * objc-act.c (objc_build_string_object): Adjust. diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c index 03b41504c4a..c379a51ba9a 100644 --- a/gcc/objc/objc-act.c +++ b/gcc/objc/objc-act.c @@ -3940,8 +3940,7 @@ objc_detect_field_duplicates (bool check_superclasses_only) { /* First, build the hashtable by putting all the instance variables of superclasses in it. */ - hash_table <decl_name_hash> htab; - htab.create (37); + hash_table<decl_name_hash> htab (37); tree interface; for (interface = lookup_interface (CLASS_SUPER_NAME (objc_interface_context)); @@ -4018,7 +4017,6 @@ objc_detect_field_duplicates (bool check_superclasses_only) } } } - htab.dispose (); return true; } } diff --git a/gcc/passes.c b/gcc/passes.c index 4ddb84a4eb1..91b644e33db 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -719,7 +719,7 @@ pass_registry_hasher::equal (const value_type *s1, const compare_type *s2) return !strcmp (s1->unique_name, s2->unique_name); } -static hash_table <pass_registry_hasher> name_to_pass_map; +static hash_table<pass_registry_hasher> *name_to_pass_map; /* Register PASS with NAME. */ @@ -729,11 +729,11 @@ register_pass_name (opt_pass *pass, const char *name) struct pass_registry **slot; struct pass_registry pr; - if (!name_to_pass_map.is_created ()) - name_to_pass_map.create (256); + if (!name_to_pass_map) + name_to_pass_map = new hash_table<pass_registry_hasher> (256); pr.unique_name = name; - slot = name_to_pass_map.find_slot (&pr, INSERT); + slot = name_to_pass_map->find_slot (&pr, INSERT); if (!*slot) { struct pass_registry *new_pr; @@ -777,7 +777,7 @@ create_pass_tab (void) return; pass_tab.safe_grow_cleared (g->get_passes ()->passes_by_id_size + 1); - name_to_pass_map.traverse <void *, passes_pass_traverse> (NULL); + name_to_pass_map->traverse <void *, passes_pass_traverse> (NULL); } static bool override_gate_status (opt_pass *, tree, bool); @@ -867,7 +867,7 @@ get_pass_by_name (const char *name) struct pass_registry **slot, pr; pr.unique_name = name; - slot = name_to_pass_map.find_slot (&pr, NO_INSERT); + slot = name_to_pass_map->find_slot (&pr, NO_INSERT); if (!slot || !*slot) return NULL; diff --git a/gcc/plugin.c b/gcc/plugin.c index 88c178097a5..8debc09cada 100644 --- a/gcc/plugin.c +++ b/gcc/plugin.c @@ -80,7 +80,7 @@ event_hasher::equal (const value_type *s1, const compare_type *s2) /* A hash table to map event names to the position of the names in the plugin_event_name table. */ -static hash_table <event_hasher> event_tab; +static hash_table<event_hasher> *event_tab; /* Keep track of the limit of allocated events and space ready for allocating events. */ @@ -345,19 +345,19 @@ get_named_event_id (const char *name, enum insert_option insert) { const char ***slot; - if (!event_tab.is_created ()) + if (!event_tab) { int i; - event_tab.create (150); + event_tab = new hash_table<event_hasher> (150); for (i = 0; i < event_last; i++) { - slot = event_tab.find_slot (&plugin_event_name[i], INSERT); + slot = event_tab->find_slot (&plugin_event_name[i], INSERT); gcc_assert (*slot == HTAB_EMPTY_ENTRY); *slot = &plugin_event_name[i]; } } - slot = event_tab.find_slot (&name, insert); + slot = event_tab->find_slot (&name, insert); if (slot == NULL) return -1; if (*slot != HTAB_EMPTY_ENTRY) @@ -383,7 +383,8 @@ get_named_event_id (const char *name, enum insert_option insert) plugin_callbacks, event_horizon); } /* All the pointers in the hash table will need to be updated. */ - event_tab.dispose (); + delete event_tab; + event_tab = NULL; } else *slot = &plugin_event_name[event_last]; diff --git a/gcc/postreload-gcse.c b/gcc/postreload-gcse.c index af2d731a94d..f2391a1e032 100644 --- a/gcc/postreload-gcse.c +++ b/gcc/postreload-gcse.c @@ -148,7 +148,7 @@ expr_hasher::equal (const value_type *exp1, const compare_type *exp2) } /* The table itself. */ -static hash_table <expr_hasher> expr_table; +static hash_table<expr_hasher> *expr_table; static struct obstack expr_obstack; @@ -279,7 +279,7 @@ alloc_mem (void) make the hash table too small, but unnecessarily making it too large also doesn't help. The i/4 is a gcse.c relic, and seems like a reasonable choice. */ - expr_table.create (MAX (i / 4, 13)); + expr_table = new hash_table<expr_hasher> (MAX (i / 4, 13)); /* We allocate everything on obstacks because we often can roll back the whole obstack to some point. Freeing obstacks is very fast. */ @@ -306,7 +306,8 @@ free_mem (void) { free (uid_cuid); - expr_table.dispose (); + delete expr_table; + expr_table = NULL; obstack_free (&expr_obstack, NULL); obstack_free (&occr_obstack, NULL); @@ -348,7 +349,7 @@ insert_expr_in_table (rtx x, rtx insn) cur_expr->hash = hash; cur_expr->avail_occr = NULL; - slot = expr_table.find_slot_with_hash (cur_expr, hash, INSERT); + slot = expr_table->find_slot_with_hash (cur_expr, hash, INSERT); if (! (*slot)) /* The expression isn't found, so insert it. */ @@ -416,7 +417,7 @@ lookup_expr_in_table (rtx pat) tmp_expr->hash = hash; tmp_expr->avail_occr = NULL; - slot = expr_table.find_slot_with_hash (tmp_expr, hash, INSERT); + slot = expr_table->find_slot_with_hash (tmp_expr, hash, INSERT); obstack_free (&expr_obstack, tmp_expr); if (!slot) @@ -457,13 +458,13 @@ dump_hash_table (FILE *file) { fprintf (file, "\n\nexpression hash table\n"); fprintf (file, "size %ld, %ld elements, %f collision/search ratio\n", - (long) expr_table.size (), - (long) expr_table.elements (), - expr_table.collisions ()); - if (expr_table.elements () > 0) + (long) expr_table->size (), + (long) expr_table->elements (), + expr_table->collisions ()); + if (expr_table->elements () > 0) { fprintf (file, "\n\ntable entries:\n"); - expr_table.traverse <FILE *, dump_expr_hash_table_entry> (file); + expr_table->traverse <FILE *, dump_expr_hash_table_entry> (file); } fprintf (file, "\n"); } @@ -1253,7 +1254,7 @@ delete_redundant_insns_1 (expr **slot, void *data ATTRIBUTE_UNUSED) static void delete_redundant_insns (void) { - expr_table.traverse <void *, delete_redundant_insns_1> (NULL); + expr_table->traverse <void *, delete_redundant_insns_1> (NULL); if (dump_file) fprintf (dump_file, "\n"); } @@ -1279,7 +1280,7 @@ gcse_after_reload_main (rtx f ATTRIBUTE_UNUSED) if (dump_file) dump_hash_table (dump_file); - if (expr_table.elements () > 0) + if (expr_table->elements () > 0) { eliminate_partially_redundant_loads (); delete_redundant_insns (); diff --git a/gcc/sese.c b/gcc/sese.c index a0b08995513..8191cb92ec4 100644 --- a/gcc/sese.c +++ b/gcc/sese.c @@ -102,15 +102,15 @@ rename_map_hasher::equal (const value_type *elt1, const compare_type *elt2) return (elt1->old_name == elt2->old_name); } -typedef hash_table <rename_map_hasher> rename_map_type; +typedef hash_table<rename_map_hasher> rename_map_type; /* Print to stderr all the elements of RENAME_MAP. */ DEBUG_FUNCTION void -debug_rename_map (rename_map_type rename_map) +debug_rename_map (rename_map_type *rename_map) { - rename_map.traverse <void *, debug_rename_map_1> (NULL); + rename_map->traverse <void *, debug_rename_map_1> (NULL); } /* Computes a hash function for database element ELT. */ @@ -416,14 +416,14 @@ get_false_edge_from_guard_bb (basic_block bb) /* Returns the expression associated to OLD_NAME in RENAME_MAP. */ static tree -get_rename (rename_map_type rename_map, tree old_name) +get_rename (rename_map_type *rename_map, tree old_name) { struct rename_map_elt_s tmp; rename_map_elt_s **slot; gcc_assert (TREE_CODE (old_name) == SSA_NAME); tmp.old_name = old_name; - slot = rename_map.find_slot (&tmp, NO_INSERT); + slot = rename_map->find_slot (&tmp, NO_INSERT); if (slot && *slot) return (*slot)->expr; @@ -434,7 +434,7 @@ get_rename (rename_map_type rename_map, tree old_name) /* Register in RENAME_MAP the rename tuple (OLD_NAME, EXPR). */ static void -set_rename (rename_map_type rename_map, tree old_name, tree expr) +set_rename (rename_map_type *rename_map, tree old_name, tree expr) { struct rename_map_elt_s tmp; rename_map_elt_s **slot; @@ -443,7 +443,7 @@ set_rename (rename_map_type rename_map, tree old_name, tree expr) return; tmp.old_name = old_name; - slot = rename_map.find_slot (&tmp, INSERT); + slot = rename_map->find_slot (&tmp, INSERT); if (!slot) return; @@ -461,7 +461,7 @@ set_rename (rename_map_type rename_map, tree old_name, tree expr) is set when the code generation cannot continue. */ static bool -rename_uses (gimple copy, rename_map_type rename_map, +rename_uses (gimple copy, rename_map_type *rename_map, gimple_stmt_iterator *gsi_tgt, sese region, loop_p loop, vec<tree> iv_map, bool *gloog_error) @@ -568,7 +568,7 @@ rename_uses (gimple copy, rename_map_type rename_map, static void graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb, - rename_map_type rename_map, + rename_map_type *rename_map, vec<tree> iv_map, sese region, bool *gloog_error) { @@ -636,14 +636,12 @@ copy_bb_and_scalar_dependences (basic_block bb, sese region, bool *gloog_error) { basic_block new_bb = split_edge (next_e); - rename_map_type rename_map; - rename_map.create (10); + rename_map_type rename_map (10); next_e = single_succ_edge (new_bb); - graphite_copy_stmts_from_block (bb, new_bb, rename_map, iv_map, region, + graphite_copy_stmts_from_block (bb, new_bb, &rename_map, iv_map, region, gloog_error); remove_phi_nodes (new_bb); - rename_map.dispose (); return next_e; } diff --git a/gcc/statistics.c b/gcc/statistics.c index 6c8470924e9..eb3210ba757 100644 --- a/gcc/statistics.c +++ b/gcc/statistics.c @@ -80,16 +80,16 @@ stats_counter_hasher::remove (value_type *v) free (v); } -typedef hash_table <stats_counter_hasher> stats_counter_table_type; +typedef hash_table<stats_counter_hasher> stats_counter_table_type; /* Array of statistic hashes, indexed by pass id. */ -static stats_counter_table_type *statistics_hashes; +static stats_counter_table_type **statistics_hashes; static unsigned nr_statistics_hashes; /* Return the current hashtable to be used for recording or printing statistics. */ -static stats_counter_table_type +static stats_counter_table_type * curr_statistics_hash (void) { unsigned idx; @@ -98,20 +98,20 @@ curr_statistics_hash (void) idx = current_pass->static_pass_number; if (idx < nr_statistics_hashes - && statistics_hashes[idx].is_created ()) + && statistics_hashes[idx]) return statistics_hashes[idx]; if (idx >= nr_statistics_hashes) { - statistics_hashes = XRESIZEVEC (stats_counter_table_type, + statistics_hashes = XRESIZEVEC (stats_counter_table_type *, statistics_hashes, idx+1); memset (statistics_hashes + nr_statistics_hashes, 0, (idx + 1 - nr_statistics_hashes) - * sizeof (stats_counter_table_type)); + * sizeof (stats_counter_table_type *)); nr_statistics_hashes = idx + 1; } - statistics_hashes[idx].create (15); + statistics_hashes[idx] = new stats_counter_table_type (15); return statistics_hashes[idx]; } @@ -195,16 +195,16 @@ statistics_fini_pass (void) fprintf (dump_file, "Pass statistics:\n"); fprintf (dump_file, "----------------\n"); curr_statistics_hash () - .traverse_noresize <void *, statistics_fini_pass_1> (NULL); + ->traverse_noresize <void *, statistics_fini_pass_1> (NULL); fprintf (dump_file, "\n"); } if (statistics_dump_file && !(statistics_dump_flags & TDF_STATS || statistics_dump_flags & TDF_DETAILS)) curr_statistics_hash () - .traverse_noresize <void *, statistics_fini_pass_2> (NULL); + ->traverse_noresize <void *, statistics_fini_pass_2> (NULL); curr_statistics_hash () - .traverse_noresize <void *, statistics_fini_pass_3> (NULL); + ->traverse_noresize <void *, statistics_fini_pass_3> (NULL); } /* Helper for printing summary information. */ @@ -245,10 +245,10 @@ statistics_fini (void) { unsigned i; for (i = 0; i < nr_statistics_hashes; ++i) - if (statistics_hashes[i].is_created () + if (statistics_hashes[i] && passes->get_pass_for_id (i) != NULL) statistics_hashes[i] - .traverse_noresize <opt_pass *, statistics_fini_1> + ->traverse_noresize <opt_pass *, statistics_fini_1> (passes->get_pass_for_id (i)); } @@ -280,14 +280,14 @@ statistics_init (void) and HISTOGRAM_P. */ static statistics_counter_t * -lookup_or_add_counter (stats_counter_table_type hash, const char *id, int val, +lookup_or_add_counter (stats_counter_table_type *hash, const char *id, int val, bool histogram_p) { statistics_counter_t **counter; statistics_counter_t c; c.id = id; c.val = val; - counter = hash.find_slot (&c, INSERT); + counter = hash->find_slot (&c, INSERT); if (!*counter) { *counter = XNEW (struct statistics_counter_s); diff --git a/gcc/store-motion.c b/gcc/store-motion.c index 18ba518eb9a..3023c0c44bb 100644 --- a/gcc/store-motion.c +++ b/gcc/store-motion.c @@ -129,7 +129,7 @@ st_expr_hasher::equal (const value_type *ptr1, const compare_type *ptr2) } /* Hashtable for the load/store memory refs. */ -static hash_table <st_expr_hasher> store_motion_mems_table; +static hash_table<st_expr_hasher> *store_motion_mems_table; /* This will search the st_expr list for a matching expression. If it doesn't find one, we create one and initialize it. */ @@ -147,7 +147,7 @@ st_expr_entry (rtx x) NULL, /*have_reg_qty=*/false); e.pattern = x; - slot = store_motion_mems_table.find_slot_with_hash (&e, hash, INSERT); + slot = store_motion_mems_table->find_slot_with_hash (&e, hash, INSERT); if (*slot) return *slot; @@ -183,8 +183,8 @@ free_st_expr_entry (struct st_expr * ptr) static void free_store_motion_mems (void) { - if (store_motion_mems_table.is_created ()) - store_motion_mems_table.dispose (); + delete store_motion_mems_table; + store_motion_mems_table = NULL; while (store_motion_mems) { @@ -651,7 +651,7 @@ compute_store_table (void) unsigned int max_gcse_regno = max_reg_num (); store_motion_mems = NULL; - store_motion_mems_table.create (13); + store_motion_mems_table = new hash_table<st_expr_hasher> (13); last_set_in = XCNEWVEC (int, max_gcse_regno); already_set = XNEWVEC (int, max_gcse_regno); @@ -713,7 +713,7 @@ compute_store_table (void) if (! ptr->avail_stores) { *prev_next_ptr_ptr = ptr->next; - store_motion_mems_table.remove_elt_with_hash (ptr, ptr->hash_index); + store_motion_mems_table->remove_elt_with_hash (ptr, ptr->hash_index); free_st_expr_entry (ptr); } else @@ -1152,7 +1152,8 @@ one_store_motion_pass (void) num_stores = compute_store_table (); if (num_stores == 0) { - store_motion_mems_table.dispose (); + delete store_motion_mems_table; + store_motion_mems_table = NULL; end_alias_analysis (); return 0; } diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c index b728d743d6e..c4baa437e98 100644 --- a/gcc/trans-mem.c +++ b/gcc/trans-mem.c @@ -982,7 +982,7 @@ log_entry_hasher::remove (value_type *lp) /* The actual log. */ -static hash_table <log_entry_hasher> tm_log; +static hash_table<log_entry_hasher> *tm_log; /* Addresses to log with a save/restore sequence. These should be in dominator order. */ @@ -1027,14 +1027,14 @@ tm_mem_map_hasher::equal (const value_type *v, const compare_type *c) /* Map for an SSA_NAME originally pointing to a non aliased new piece of memory (malloc, alloc, etc). */ -static hash_table <tm_mem_map_hasher> tm_new_mem_hash; +static hash_table<tm_mem_map_hasher> *tm_new_mem_hash; /* Initialize logging data structures. */ static void tm_log_init (void) { - tm_log.create (10); - tm_new_mem_hash.create (5); + tm_log = new hash_table<log_entry_hasher> (10); + tm_new_mem_hash = new hash_table<tm_mem_map_hasher> (5); tm_log_save_addresses.create (5); } @@ -1042,8 +1042,10 @@ tm_log_init (void) static void tm_log_delete (void) { - tm_log.dispose (); - tm_new_mem_hash.dispose (); + delete tm_log; + tm_log = NULL; + delete tm_new_mem_hash; + tm_new_mem_hash = NULL; tm_log_save_addresses.release (); } @@ -1088,7 +1090,7 @@ tm_log_add (basic_block entry_block, tree addr, gimple stmt) struct tm_log_entry l, *lp; l.addr = addr; - slot = tm_log.find_slot (&l, INSERT); + slot = tm_log->find_slot (&l, INSERT); if (!*slot) { tree type = TREE_TYPE (addr); @@ -1231,10 +1233,10 @@ tm_log_emit_stmt (tree addr, gimple stmt) static void tm_log_emit (void) { - hash_table <log_entry_hasher>::iterator hi; + hash_table<log_entry_hasher>::iterator hi; struct tm_log_entry *lp; - FOR_EACH_HASH_TABLE_ELEMENT (tm_log, lp, tm_log_entry_t, hi) + FOR_EACH_HASH_TABLE_ELEMENT (*tm_log, lp, tm_log_entry_t, hi) { size_t i; gimple stmt; @@ -1276,7 +1278,7 @@ tm_log_emit_saves (basic_block entry_block, basic_block bb) for (i = 0; i < tm_log_save_addresses.length (); ++i) { l.addr = tm_log_save_addresses[i]; - lp = *(tm_log.find_slot (&l, NO_INSERT)); + lp = *(tm_log->find_slot (&l, NO_INSERT)); gcc_assert (lp->save_var != NULL); /* We only care about variables in the current transaction. */ @@ -1312,7 +1314,7 @@ tm_log_emit_restores (basic_block entry_block, basic_block bb) for (i = tm_log_save_addresses.length () - 1; i >= 0; i--) { l.addr = tm_log_save_addresses[i]; - lp = *(tm_log.find_slot (&l, NO_INSERT)); + lp = *(tm_log->find_slot (&l, NO_INSERT)); gcc_assert (lp->save_var != NULL); /* We only care about variables in the current transaction. */ @@ -1363,7 +1365,7 @@ thread_private_new_memory (basic_block entry_block, tree x) /* Look in cache first. */ elt.val = x; - slot = tm_new_mem_hash.find_slot (&elt, INSERT); + slot = tm_new_mem_hash->find_slot (&elt, INSERT); elt_p = *slot; if (elt_p) return elt_p->local_new_memory; @@ -3340,7 +3342,7 @@ static bitmap_obstack tm_memopt_obstack; /* Unique counter for TM loads and stores. Loads and stores of the same address get the same ID. */ static unsigned int tm_memopt_value_id; -static hash_table <tm_memop_hasher> tm_memopt_value_numbers; +static hash_table<tm_memop_hasher> *tm_memopt_value_numbers; #define STORE_AVAIL_IN(BB) \ ((struct tm_memopt_bitmaps *) ((BB)->aux))->store_avail_in @@ -3374,7 +3376,7 @@ tm_memopt_value_number (gimple stmt, enum insert_option op) gcc_assert (is_tm_load (stmt) || is_tm_store (stmt)); tmpmem.addr = gimple_call_arg (stmt, 0); - slot = tm_memopt_value_numbers.find_slot (&tmpmem, op); + slot = tm_memopt_value_numbers->find_slot (&tmpmem, op); if (*slot) mem = *slot; else if (op == INSERT) @@ -3434,11 +3436,11 @@ dump_tm_memopt_set (const char *set_name, bitmap bits) fprintf (dump_file, "TM memopt: %s: [", set_name); EXECUTE_IF_SET_IN_BITMAP (bits, 0, i, bi) { - hash_table <tm_memop_hasher>::iterator hi; + hash_table<tm_memop_hasher>::iterator hi; struct tm_memop *mem = NULL; /* Yeah, yeah, yeah. Whatever. This is just for debugging. */ - FOR_EACH_HASH_TABLE_ELEMENT (tm_memopt_value_numbers, mem, tm_memop_t, hi) + FOR_EACH_HASH_TABLE_ELEMENT (*tm_memopt_value_numbers, mem, tm_memop_t, hi) if (mem->value_id == i) break; gcc_assert (mem->value_id == i); @@ -3874,7 +3876,7 @@ execute_tm_memopt (void) vec<basic_block> bbs; tm_memopt_value_id = 0; - tm_memopt_value_numbers.create (10); + tm_memopt_value_numbers = new hash_table<tm_memop_hasher> (10); for (region = all_tm_regions; region; region = region->next) { @@ -3908,10 +3910,11 @@ execute_tm_memopt (void) tm_memopt_free_sets (bbs); bbs.release (); bitmap_obstack_release (&tm_memopt_obstack); - tm_memopt_value_numbers.empty (); + tm_memopt_value_numbers->empty (); } - tm_memopt_value_numbers.dispose (); + delete tm_memopt_value_numbers; + tm_memopt_value_numbers = NULL; return 0; } diff --git a/gcc/tree-browser.c b/gcc/tree-browser.c index 40fa2e95de0..8c03550d58c 100644 --- a/gcc/tree-browser.c +++ b/gcc/tree-browser.c @@ -134,7 +134,7 @@ tree_upper_hasher::equal (const value_type *parent, const compare_type *node) } /* Static variables. */ -static hash_table <tree_upper_hasher> TB_up_ht; +static hash_table<tree_upper_hasher> *TB_up_ht; static vec<tree, va_gc> *TB_history_stack; static int TB_verbose = 1; @@ -167,7 +167,7 @@ browse_tree (tree begin) /* Store in a hashtable information about previous and upper statements. */ { - TB_up_ht.create (1023); + TB_up_ht = new hash_table<tree_upper_hasher> (1023); TB_update_up (head); } @@ -645,7 +645,8 @@ browse_tree (tree begin) } ret:; - TB_up_ht.dispose (); + delete TB_up_ht; + TB_up_ht = NULL; return; } @@ -691,7 +692,7 @@ TB_up_expr (tree node) if (node == NULL_TREE) return NULL_TREE; - res = TB_up_ht.find (node); + res = TB_up_ht->find (node); return res; } @@ -769,7 +770,7 @@ store_child_info (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, for (i = 0; i < n; i++) { tree op = TREE_OPERAND (node, i); - slot = TB_up_ht.find_slot (op, INSERT); + slot = TB_up_ht->find_slot (op, INSERT); *slot = node; } } diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index e8246198147..0a1c4fb93d1 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -143,7 +143,7 @@ locus_discrim_hasher::equal (const value_type *a, const compare_type *b) return LOCATION_LINE (a->locus) == LOCATION_LINE (b->locus); } -static hash_table <locus_discrim_hasher> discriminator_per_locus; +static hash_table<locus_discrim_hasher> *discriminator_per_locus; /* Basic blocks and flowgraphs. */ static void make_blocks (gimple_seq); @@ -244,11 +244,12 @@ build_gimple_cfg (gimple_seq seq) group_case_labels (); /* Create the edges of the flowgraph. */ - discriminator_per_locus.create (13); + discriminator_per_locus = new hash_table<locus_discrim_hasher> (13); make_edges (); assign_discriminators (); cleanup_dead_labels (); - discriminator_per_locus.dispose (); + delete discriminator_per_locus; + discriminator_per_locus = NULL; } @@ -938,7 +939,7 @@ next_discriminator_for_locus (location_t locus) item.locus = locus; item.discriminator = 0; - slot = discriminator_per_locus.find_slot_with_hash ( + slot = discriminator_per_locus->find_slot_with_hash ( &item, LOCATION_LINE (locus), INSERT); gcc_assert (slot); if (*slot == HTAB_EMPTY_ENTRY) diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c index eefb952d5bb..7b0115d0f52 100644 --- a/gcc/tree-complex.c +++ b/gcc/tree-complex.c @@ -73,7 +73,7 @@ static vec<complex_lattice_t> complex_lattice_values; /* For each complex variable, a pair of variables for the components exists in the hashtable. */ -static int_tree_htab_type complex_variable_components; +static int_tree_htab_type *complex_variable_components; /* For each complex SSA_NAME, a pair of ssa names for the components. */ static vec<tree> complex_ssa_name_components; @@ -85,7 +85,7 @@ cvc_lookup (unsigned int uid) { struct int_tree_map *h, in; in.uid = uid; - h = complex_variable_components.find_with_hash (&in, uid); + h = complex_variable_components->find_with_hash (&in, uid); return h ? h->to : NULL; } @@ -100,7 +100,7 @@ cvc_insert (unsigned int uid, tree to) h = XNEW (struct int_tree_map); h->uid = uid; h->to = to; - loc = complex_variable_components.find_slot_with_hash (h, uid, INSERT); + loc = complex_variable_components->find_slot_with_hash (h, uid, INSERT); *loc = h; } @@ -1629,7 +1629,7 @@ tree_lower_complex (void) init_parameter_lattice_values (); ssa_propagate (complex_visit_stmt, complex_visit_phi); - complex_variable_components.create (10); + complex_variable_components = new int_tree_htab_type (10); complex_ssa_name_components.create (2 * num_ssa_names); complex_ssa_name_components.safe_grow_cleared (2 * num_ssa_names); @@ -1650,7 +1650,8 @@ tree_lower_complex (void) gsi_commit_edge_inserts (); - complex_variable_components.dispose (); + delete complex_variable_components; + complex_variable_components = NULL; complex_ssa_name_components.release (); complex_lattice_values.release (); return 0; diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c index 9f8408d71d3..ec3d425d757 100644 --- a/gcc/tree-eh.c +++ b/gcc/tree-eh.c @@ -225,7 +225,7 @@ finally_tree_hasher::equal (const value_type *v, const compare_type *c) } /* Note that this table is *not* marked GTY. It is short-lived. */ -static hash_table <finally_tree_hasher> finally_tree; +static hash_table<finally_tree_hasher> *finally_tree; static void record_in_finally_tree (treemple child, gimple parent) @@ -237,7 +237,7 @@ record_in_finally_tree (treemple child, gimple parent) n->child = child; n->parent = parent; - slot = finally_tree.find_slot (n, INSERT); + slot = finally_tree->find_slot (n, INSERT); gcc_assert (!*slot); *slot = n; } @@ -316,7 +316,7 @@ outside_finally_tree (treemple start, gimple target) do { n.child = start; - p = finally_tree.find (&n); + p = finally_tree->find (&n); if (!p) return true; start.g = p->parent; @@ -2161,7 +2161,7 @@ pass_lower_eh::execute (function *fun) if (bodyp == NULL) return 0; - finally_tree.create (31); + finally_tree = new hash_table<finally_tree_hasher> (31); eh_region_may_contain_throw_map = BITMAP_ALLOC (NULL); memset (&null_state, 0, sizeof (null_state)); @@ -2179,7 +2179,8 @@ pass_lower_eh::execute (function *fun) didn't change its value, and we don't have to re-set the function. */ gcc_assert (bodyp == gimple_body (current_function_decl)); - finally_tree.dispose (); + delete finally_tree; + finally_tree = NULL; BITMAP_FREE (eh_region_may_contain_throw_map); eh_seq = NULL; diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c index 5b541037c3a..1cdcc2faa7c 100644 --- a/gcc/tree-into-ssa.c +++ b/gcc/tree-into-ssa.c @@ -224,7 +224,7 @@ var_info_hasher::equal (const value_type *p1, const compare_type *p2) /* Each entry in VAR_INFOS contains an element of type STRUCT VAR_INFO_D. */ -static hash_table <var_info_hasher> var_infos; +static hash_table<var_info_hasher> *var_infos; /* Information stored for SSA names. */ @@ -383,7 +383,7 @@ get_var_info (tree decl) struct var_info_d vi; var_info_d **slot; vi.var = decl; - slot = var_infos.find_slot_with_hash (&vi, DECL_UID (decl), INSERT); + slot = var_infos->find_slot_with_hash (&vi, DECL_UID (decl), INSERT); if (*slot == NULL) { var_info_p v = XCNEW (struct var_info_d); @@ -1084,14 +1084,14 @@ insert_phi_nodes_compare_var_infos (const void *a, const void *b) static void insert_phi_nodes (bitmap_head *dfs) { - hash_table <var_info_hasher>::iterator hi; + hash_table<var_info_hasher>::iterator hi; unsigned i; var_info_p info; timevar_push (TV_TREE_INSERT_PHI_NODES); - auto_vec<var_info_p> vars (var_infos.elements ()); - FOR_EACH_HASH_TABLE_ELEMENT (var_infos, info, var_info_p, hi) + auto_vec<var_info_p> vars (var_infos->elements ()); + FOR_EACH_HASH_TABLE_ELEMENT (*var_infos, info, var_info_p, hi) if (info->info.need_phi_state != NEED_PHI_STATE_NO) vars.quick_push (info); @@ -1654,7 +1654,7 @@ debug_tree_ssa (void) /* Dump statistics for the hash table HTAB. */ static void -htab_statistics (FILE *file, hash_table <var_info_hasher> htab) +htab_statistics (FILE *file, const hash_table<var_info_hasher> &htab) { fprintf (file, "size %ld, %ld elements, %f collision/search ratio\n", (long) htab.size (), @@ -1668,11 +1668,11 @@ htab_statistics (FILE *file, hash_table <var_info_hasher> htab) void dump_tree_ssa_stats (FILE *file) { - if (var_infos.is_created ()) + if (var_infos) { fprintf (file, "\nHash table statistics:\n"); fprintf (file, " var_infos: "); - htab_statistics (file, var_infos); + htab_statistics (file, *var_infos); fprintf (file, "\n"); } } @@ -1713,8 +1713,8 @@ void dump_var_infos (FILE *file) { fprintf (file, "\n\nDefinition and live-in blocks:\n\n"); - if (var_infos.is_created ()) - var_infos.traverse <FILE *, debug_var_infos_r> (file); + if (var_infos) + var_infos->traverse <FILE *, debug_var_infos_r> (file); } @@ -2206,7 +2206,7 @@ rewrite_blocks (basic_block entry, enum rewrite_mode what) if (dump_file && (dump_flags & TDF_STATS)) { dump_dfa_stats (dump_file); - if (var_infos.is_created ()) + if (var_infos) dump_tree_ssa_stats (dump_file); } @@ -2261,8 +2261,9 @@ init_ssa_renamer (void) cfun->gimple_df->in_ssa_p = false; /* Allocate memory for the DEF_BLOCKS hash table. */ - gcc_assert (!var_infos.is_created ()); - var_infos.create (vec_safe_length (cfun->local_decls)); + gcc_assert (!var_infos); + var_infos = new hash_table<var_info_hasher> + (vec_safe_length (cfun->local_decls)); bitmap_obstack_initialize (&update_ssa_obstack); } @@ -2273,8 +2274,8 @@ init_ssa_renamer (void) static void fini_ssa_renamer (void) { - if (var_infos.is_created ()) - var_infos.dispose (); + delete var_infos; + var_infos = NULL; bitmap_obstack_release (&update_ssa_obstack); @@ -3208,7 +3209,7 @@ update_ssa (unsigned update_flags) { /* If we rename bare symbols initialize the mapping to auxiliar info we need to keep track of. */ - var_infos.create (47); + var_infos = new hash_table<var_info_hasher> (47); /* If we have to rename some symbols from scratch, we need to start the process at the root of the CFG. FIXME, it should diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c index 3bc6a2bbf23..3ef4aa632e0 100644 --- a/gcc/tree-parloops.c +++ b/gcc/tree-parloops.c @@ -227,20 +227,20 @@ reduction_hasher::hash (const value_type *a) return a->reduc_version; } -typedef hash_table <reduction_hasher> reduction_info_table_type; +typedef hash_table<reduction_hasher> reduction_info_table_type; static struct reduction_info * -reduction_phi (reduction_info_table_type reduction_list, gimple phi) +reduction_phi (reduction_info_table_type *reduction_list, gimple phi) { struct reduction_info tmpred, *red; - if (reduction_list.elements () == 0 || phi == NULL) + if (reduction_list->elements () == 0 || phi == NULL) return NULL; tmpred.reduc_phi = phi; tmpred.reduc_version = gimple_uid (phi); - red = reduction_list.find (&tmpred); + red = reduction_list->find (&tmpred); return red; } @@ -279,7 +279,7 @@ name_to_copy_hasher::hash (const value_type *a) return (hashval_t) a->version; } -typedef hash_table <name_to_copy_hasher> name_to_copy_table_type; +typedef hash_table<name_to_copy_hasher> name_to_copy_table_type; /* A transformation matrix, which is a self-contained ROWSIZE x COLSIZE matrix. Rather than use floats, we simply keep a single DENOMINATOR that @@ -486,7 +486,7 @@ loop_has_blocks_with_irreducible_flag (struct loop *loop) static tree take_address_of (tree obj, tree type, edge entry, - int_tree_htab_type decl_address, gimple_stmt_iterator *gsi) + int_tree_htab_type *decl_address, gimple_stmt_iterator *gsi) { int uid; int_tree_map **dslot; @@ -512,7 +512,7 @@ take_address_of (tree obj, tree type, edge entry, on it. */ uid = DECL_UID (TREE_OPERAND (TREE_OPERAND (*var_p, 0), 0)); ielt.uid = uid; - dslot = decl_address.find_slot_with_hash (&ielt, uid, INSERT); + dslot = decl_address->find_slot_with_hash (&ielt, uid, INSERT); if (!*dslot) { if (gsi == NULL) @@ -609,7 +609,7 @@ struct elv_data { struct walk_stmt_info info; edge entry; - int_tree_htab_type decl_address; + int_tree_htab_type *decl_address; gimple_stmt_iterator *gsi; bool changed; bool reset; @@ -699,7 +699,7 @@ eliminate_local_variables_1 (tree *tp, int *walk_subtrees, void *data) static void eliminate_local_variables_stmt (edge entry, gimple_stmt_iterator *gsi, - int_tree_htab_type decl_address) + int_tree_htab_type *decl_address) { struct elv_data dta; gimple stmt = gsi_stmt (*gsi); @@ -756,8 +756,7 @@ eliminate_local_variables (edge entry, edge exit) unsigned i; gimple_stmt_iterator gsi; bool has_debug_stmt = false; - int_tree_htab_type decl_address; - decl_address.create (10); + int_tree_htab_type decl_address (10); basic_block entry_bb = entry->src; basic_block exit_bb = exit->dest; @@ -772,16 +771,14 @@ eliminate_local_variables (edge entry, edge exit) has_debug_stmt = true; } else - eliminate_local_variables_stmt (entry, &gsi, decl_address); + eliminate_local_variables_stmt (entry, &gsi, &decl_address); if (has_debug_stmt) FOR_EACH_VEC_ELT (body, i, bb) if (bb != entry_bb && bb != exit_bb) for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) if (gimple_debug_bind_p (gsi_stmt (gsi))) - eliminate_local_variables_stmt (entry, &gsi, decl_address); - - decl_address.dispose (); + eliminate_local_variables_stmt (entry, &gsi, &decl_address); } /* Returns true if expression EXPR is not defined between ENTRY and @@ -819,8 +816,9 @@ expr_invariant_in_region_p (edge entry, edge exit, tree expr) duplicated, storing the copies in DECL_COPIES. */ static tree -separate_decls_in_region_name (tree name, name_to_copy_table_type name_copies, - int_tree_htab_type decl_copies, bool copy_name_p) +separate_decls_in_region_name (tree name, name_to_copy_table_type *name_copies, + int_tree_htab_type *decl_copies, + bool copy_name_p) { tree copy, var, var_copy; unsigned idx, uid, nuid; @@ -834,8 +832,8 @@ separate_decls_in_region_name (tree name, name_to_copy_table_type name_copies, idx = SSA_NAME_VERSION (name); elt.version = idx; - slot = name_copies.find_slot_with_hash (&elt, idx, - copy_name_p ? INSERT : NO_INSERT); + slot = name_copies->find_slot_with_hash (&elt, idx, + copy_name_p ? INSERT : NO_INSERT); if (slot && *slot) return (*slot)->new_name; @@ -860,7 +858,7 @@ separate_decls_in_region_name (tree name, name_to_copy_table_type name_copies, uid = DECL_UID (var); ielt.uid = uid; - dslot = decl_copies.find_slot_with_hash (&ielt, uid, INSERT); + dslot = decl_copies->find_slot_with_hash (&ielt, uid, INSERT); if (!*dslot) { var_copy = create_tmp_var (TREE_TYPE (var), get_name (var)); @@ -874,7 +872,7 @@ separate_decls_in_region_name (tree name, name_to_copy_table_type name_copies, it again. */ nuid = DECL_UID (var_copy); ielt.uid = nuid; - dslot = decl_copies.find_slot_with_hash (&ielt, nuid, INSERT); + dslot = decl_copies->find_slot_with_hash (&ielt, nuid, INSERT); gcc_assert (!*dslot); nielt = XNEW (struct int_tree_map); nielt->uid = nuid; @@ -897,8 +895,8 @@ separate_decls_in_region_name (tree name, name_to_copy_table_type name_copies, static void separate_decls_in_region_stmt (edge entry, edge exit, gimple stmt, - name_to_copy_table_type name_copies, - int_tree_htab_type decl_copies) + name_to_copy_table_type *name_copies, + int_tree_htab_type *decl_copies) { use_operand_p use; def_operand_p def; @@ -937,8 +935,8 @@ separate_decls_in_region_stmt (edge entry, edge exit, gimple stmt, static bool separate_decls_in_region_debug (gimple stmt, - name_to_copy_table_type name_copies, - int_tree_htab_type decl_copies) + name_to_copy_table_type *name_copies, + int_tree_htab_type *decl_copies) { use_operand_p use; ssa_op_iter oi; @@ -958,7 +956,7 @@ separate_decls_in_region_debug (gimple stmt, return true; gcc_assert (DECL_P (var) && SSA_VAR_P (var)); ielt.uid = DECL_UID (var); - dslot = decl_copies.find_slot_with_hash (&ielt, ielt.uid, NO_INSERT); + dslot = decl_copies->find_slot_with_hash (&ielt, ielt.uid, NO_INSERT); if (!dslot) return true; if (gimple_debug_bind_p (stmt)) @@ -973,7 +971,7 @@ separate_decls_in_region_debug (gimple stmt, continue; elt.version = SSA_NAME_VERSION (name); - slot = name_copies.find_slot_with_hash (&elt, elt.version, NO_INSERT); + slot = name_copies->find_slot_with_hash (&elt, elt.version, NO_INSERT); if (!slot) { gimple_debug_bind_reset_value (stmt); @@ -1133,14 +1131,14 @@ create_call_for_reduction_1 (reduction_info **slot, struct clsn_data *clsn_data) shared data is stored in and loaded from. */ static void create_call_for_reduction (struct loop *loop, - reduction_info_table_type reduction_list, + reduction_info_table_type *reduction_list, struct clsn_data *ld_st_data) { - reduction_list.traverse <struct loop *, create_phi_for_local_result> (loop); + reduction_list->traverse <struct loop *, create_phi_for_local_result> (loop); /* Find the fallthru edge from GIMPLE_OMP_CONTINUE. */ ld_st_data->load_bb = FALLTHRU_EDGE (loop->latch)->dest; reduction_list - .traverse <struct clsn_data *, create_call_for_reduction_1> (ld_st_data); + ->traverse <struct clsn_data *, create_call_for_reduction_1> (ld_st_data); } /* Callback for htab_traverse. Loads the final reduction value at the @@ -1182,7 +1180,7 @@ create_loads_for_reductions (reduction_info **slot, struct clsn_data *clsn_data) REDUCTION_LIST describes the list of reductions that the loads should be generated for. */ static void -create_final_loads_for_reduction (reduction_info_table_type reduction_list, +create_final_loads_for_reduction (reduction_info_table_type *reduction_list, struct clsn_data *ld_st_data) { gimple_stmt_iterator gsi; @@ -1196,7 +1194,7 @@ create_final_loads_for_reduction (reduction_info_table_type reduction_list, gsi_insert_before (&gsi, stmt, GSI_NEW_STMT); reduction_list - .traverse <struct clsn_data *, create_loads_for_reductions> (ld_st_data); + ->traverse <struct clsn_data *, create_loads_for_reductions> (ld_st_data); } @@ -1288,17 +1286,15 @@ create_loads_and_stores_for_name (name_to_copy_elt **slot, static void separate_decls_in_region (edge entry, edge exit, - reduction_info_table_type reduction_list, + reduction_info_table_type *reduction_list, tree *arg_struct, tree *new_arg_struct, struct clsn_data *ld_st_data) { basic_block bb1 = split_edge (entry); basic_block bb0 = single_pred (bb1); - name_to_copy_table_type name_copies; - name_copies.create (10); - int_tree_htab_type decl_copies; - decl_copies.create (10); + name_to_copy_table_type name_copies (10); + int_tree_htab_type decl_copies (10); unsigned i; tree type, type_name, nvar; gimple_stmt_iterator gsi; @@ -1318,7 +1314,7 @@ separate_decls_in_region (edge entry, edge exit, { for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) separate_decls_in_region_stmt (entry, exit, gsi_stmt (gsi), - name_copies, decl_copies); + &name_copies, &decl_copies); for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) { @@ -1328,7 +1324,7 @@ separate_decls_in_region (edge entry, edge exit, has_debug_stmt = true; else separate_decls_in_region_stmt (entry, exit, stmt, - name_copies, decl_copies); + &name_copies, &decl_copies); } } } @@ -1349,8 +1345,8 @@ separate_decls_in_region (edge entry, edge exit, if (is_gimple_debug (stmt)) { - if (separate_decls_in_region_debug (stmt, name_copies, - decl_copies)) + if (separate_decls_in_region_debug (stmt, &name_copies, + &decl_copies)) { gsi_remove (&gsi, true); continue; @@ -1361,7 +1357,7 @@ separate_decls_in_region (edge entry, edge exit, } } - if (name_copies.elements () == 0 && reduction_list.elements () == 0) + if (name_copies.elements () == 0 && reduction_list->elements () == 0) { /* It may happen that there is nothing to copy (if there are only loop carried and external variables in the loop). */ @@ -1378,10 +1374,10 @@ separate_decls_in_region (edge entry, edge exit, TYPE_NAME (type) = type_name; name_copies.traverse <tree, add_field_for_name> (type); - if (reduction_list.is_created () && reduction_list.elements () > 0) + if (reduction_list && reduction_list->elements () > 0) { /* Create the fields for reductions. */ - reduction_list.traverse <tree, add_field_for_reduction> (type); + reduction_list->traverse <tree, add_field_for_reduction> (type); } layout_type (type); @@ -1401,20 +1397,17 @@ separate_decls_in_region (edge entry, edge exit, /* Load the calculation from memory (after the join of the threads). */ - if (reduction_list.is_created () && reduction_list.elements () > 0) + if (reduction_list && reduction_list->elements () > 0) { reduction_list - .traverse <struct clsn_data *, create_stores_for_reduction> - (ld_st_data); + ->traverse <struct clsn_data *, create_stores_for_reduction> + (ld_st_data); clsn_data.load = make_ssa_name (nvar, NULL); clsn_data.load_bb = exit->dest; clsn_data.store = ld_st_data->store; create_final_loads_for_reduction (reduction_list, &clsn_data); } } - - decl_copies.dispose (); - name_copies.dispose (); } /* Bitmap containing uids of functions created by parallelization. We cannot @@ -1504,7 +1497,7 @@ create_loop_fn (location_t loc) static void transform_to_exit_first_loop (struct loop *loop, - reduction_info_table_type reduction_list, + reduction_info_table_type *reduction_list, tree nit) { basic_block *bbs, *nbbs, ex_bb, orig_header; @@ -1574,7 +1567,7 @@ transform_to_exit_first_loop (struct loop *loop, PHI_RESULT of this phi is the resulting value of the reduction variable when exiting the loop. */ - if (reduction_list.elements () > 0) + if (reduction_list->elements () > 0) { struct reduction_info *red; @@ -1749,7 +1742,8 @@ create_parallel_loop (struct loop *loop, tree loop_fn, tree data, REDUCTION_LIST describes the reductions existent in the LOOP. */ static void -gen_parallel_loop (struct loop *loop, reduction_info_table_type reduction_list, +gen_parallel_loop (struct loop *loop, + reduction_info_table_type *reduction_list, unsigned n_threads, struct tree_niter_desc *niter) { tree many_iterations_cond, type, nit; @@ -1874,8 +1868,8 @@ gen_parallel_loop (struct loop *loop, reduction_info_table_type reduction_list, transform_to_exit_first_loop (loop, reduction_list, nit); /* Generate initializations for reductions. */ - if (reduction_list.elements () > 0) - reduction_list.traverse <struct loop *, initialize_reductions> (loop); + if (reduction_list->elements () > 0) + reduction_list->traverse <struct loop *, initialize_reductions> (loop); /* Eliminate the references to local variables from the loop. */ gcc_assert (single_exit (loop)); @@ -1895,7 +1889,7 @@ gen_parallel_loop (struct loop *loop, reduction_info_table_type reduction_list, loc = gimple_location (cond_stmt); parallel_head = create_parallel_loop (loop, create_loop_fn (loc), arg_struct, new_arg_struct, n_threads, loc); - if (reduction_list.elements () > 0) + if (reduction_list->elements () > 0) create_call_for_reduction (loop, reduction_list, &clsn_data); scev_reset (); @@ -1942,7 +1936,7 @@ loop_has_vector_phi_nodes (struct loop *loop ATTRIBUTE_UNUSED) and PHI, insert it to the REDUCTION_LIST. */ static void -build_new_reduction (reduction_info_table_type reduction_list, +build_new_reduction (reduction_info_table_type *reduction_list, gimple reduc_stmt, gimple phi) { reduction_info **slot; @@ -1964,7 +1958,7 @@ build_new_reduction (reduction_info_table_type reduction_list, new_reduction->reduc_phi = phi; new_reduction->reduc_version = SSA_NAME_VERSION (gimple_phi_result (phi)); new_reduction->reduction_code = gimple_assign_rhs_code (reduc_stmt); - slot = reduction_list.find_slot (new_reduction, INSERT); + slot = reduction_list->find_slot (new_reduction, INSERT); *slot = new_reduction; } @@ -1981,7 +1975,7 @@ set_reduc_phi_uids (reduction_info **slot, void *data ATTRIBUTE_UNUSED) /* Detect all reductions in the LOOP, insert them into REDUCTION_LIST. */ static void -gather_scalar_reductions (loop_p loop, reduction_info_table_type reduction_list) +gather_scalar_reductions (loop_p loop, reduction_info_table_type *reduction_list) { gimple_stmt_iterator gsi; loop_vec_info simple_loop_info; @@ -2013,7 +2007,7 @@ gather_scalar_reductions (loop_p loop, reduction_info_table_type reduction_list) /* As gimple_uid is used by the vectorizer in between vect_analyze_loop_form and destroy_loop_vec_info, we can set gimple_uid of reduc_phi stmts only now. */ - reduction_list.traverse <void *, set_reduc_phi_uids> (NULL); + reduction_list->traverse <void *, set_reduc_phi_uids> (NULL); } /* Try to initialize NITER for code generation part. */ @@ -2043,7 +2037,7 @@ try_get_loop_niter (loop_p loop, struct tree_niter_desc *niter) static bool try_create_reduction_list (loop_p loop, - reduction_info_table_type reduction_list) + reduction_info_table_type *reduction_list) { edge exit = single_dom_exit (loop); gimple_stmt_iterator gsi; @@ -2074,7 +2068,7 @@ try_create_reduction_list (loop_p loop, fprintf (dump_file, " checking if it a part of reduction pattern: \n"); } - if (reduction_list.elements () == 0) + if (reduction_list->elements () == 0) { if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, @@ -2147,7 +2141,6 @@ parallelize_loops (void) bool changed = false; struct loop *loop; struct tree_niter_desc niter_desc; - reduction_info_table_type reduction_list; struct obstack parloop_obstack; HOST_WIDE_INT estimated; source_location loop_loc; @@ -2159,7 +2152,7 @@ parallelize_loops (void) return false; gcc_obstack_init (&parloop_obstack); - reduction_list.create (10); + reduction_info_table_type reduction_list (10); init_stmt_vec_info_vec (); FOR_EACH_LOOP (loop, 0) @@ -2215,7 +2208,7 @@ parallelize_loops (void) if (!try_get_loop_niter (loop, &niter_desc)) continue; - if (!try_create_reduction_list (loop, reduction_list)) + if (!try_create_reduction_list (loop, &reduction_list)) continue; if (!flag_loop_parallelize_all @@ -2234,12 +2227,11 @@ parallelize_loops (void) fprintf (dump_file, "\nloop at %s:%d: ", LOCATION_FILE (loop_loc), LOCATION_LINE (loop_loc)); } - gen_parallel_loop (loop, reduction_list, + gen_parallel_loop (loop, &reduction_list, n_threads, &niter_desc); } free_stmt_vec_info_vec (); - reduction_list.dispose (); obstack_free (&parloop_obstack, NULL); /* Parallelization will cause new function calls to be inserted through diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 0afa197059c..3dac50f798b 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -320,7 +320,7 @@ uid_decl_hasher::equal (const value_type *a, const compare_type *b) /* Set of candidates. */ static bitmap candidate_bitmap; -static hash_table <uid_decl_hasher> candidates; +static hash_table<uid_decl_hasher> *candidates; /* For a candidate UID return the candidates decl. */ @@ -329,7 +329,7 @@ candidate (unsigned uid) { tree_node t; t.decl_minimal.uid = uid; - return candidates.find_with_hash (&t, static_cast <hashval_t> (uid)); + return candidates->find_with_hash (&t, static_cast <hashval_t> (uid)); } /* Bitmap of candidates which we should try to entirely scalarize away and @@ -660,7 +660,8 @@ static void sra_initialize (void) { candidate_bitmap = BITMAP_ALLOC (NULL); - candidates.create (vec_safe_length (cfun->local_decls) / 2); + candidates = new hash_table<uid_decl_hasher> + (vec_safe_length (cfun->local_decls) / 2); should_scalarize_away_bitmap = BITMAP_ALLOC (NULL); cannot_scalarize_away_bitmap = BITMAP_ALLOC (NULL); gcc_obstack_init (&name_obstack); @@ -690,7 +691,8 @@ static void sra_deinitialize (void) { BITMAP_FREE (candidate_bitmap); - candidates.dispose (); + delete candidates; + candidates = NULL; BITMAP_FREE (should_scalarize_away_bitmap); BITMAP_FREE (cannot_scalarize_away_bitmap); free_alloc_pool (access_pool); @@ -707,9 +709,7 @@ static void disqualify_candidate (tree decl, const char *reason) { if (bitmap_clear_bit (candidate_bitmap, DECL_UID (decl))) - candidates.clear_slot (candidates.find_slot_with_hash (decl, - DECL_UID (decl), - NO_INSERT)); + candidates->remove_elt_with_hash (decl, DECL_UID (decl)); if (dump_file && (dump_flags & TDF_DETAILS)) { @@ -1833,7 +1833,7 @@ maybe_add_sra_candidate (tree var) } bitmap_set_bit (candidate_bitmap, DECL_UID (var)); - slot = candidates.find_slot_with_hash (var, DECL_UID (var), INSERT); + slot = candidates->find_slot_with_hash (var, DECL_UID (var), INSERT); *slot = var; if (dump_file && (dump_flags & TDF_DETAILS)) @@ -3792,7 +3792,7 @@ find_param_candidates (void) continue; bitmap_set_bit (candidate_bitmap, DECL_UID (parm)); - slot = candidates.find_slot_with_hash (parm, DECL_UID (parm), INSERT); + slot = candidates->find_slot_with_hash (parm, DECL_UID (parm), INSERT); *slot = parm; ret = true; diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c index 66b897743ec..875ba1a5276 100644 --- a/gcc/tree-ssa-ccp.c +++ b/gcc/tree-ssa-ccp.c @@ -1896,14 +1896,14 @@ evaluate_stmt (gimple stmt) return val; } -typedef hash_table <pointer_hash <gimple_statement_base> > gimple_htab; +typedef hash_table<pointer_hash<gimple_statement_base> > gimple_htab; /* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before each matching BUILT_IN_STACK_RESTORE. Mark visited phis in VISITED. */ static void insert_clobber_before_stack_restore (tree saved_val, tree var, - gimple_htab *visited) + gimple_htab **visited) { gimple stmt, clobber_stmt; tree clobber; @@ -1924,10 +1924,10 @@ insert_clobber_before_stack_restore (tree saved_val, tree var, } else if (gimple_code (stmt) == GIMPLE_PHI) { - if (!visited->is_created ()) - visited->create (10); + if (!*visited) + *visited = new gimple_htab (10); - slot = visited->find_slot (stmt, INSERT); + slot = (*visited)->find_slot (stmt, INSERT); if (*slot != NULL) continue; @@ -1973,7 +1973,7 @@ insert_clobbers_for_var (gimple_stmt_iterator i, tree var) { gimple stmt; tree saved_val; - gimple_htab visited; + gimple_htab *visited = NULL; for (; !gsi_end_p (i); gsi_prev_dom_bb_nondebug (&i)) { @@ -1990,8 +1990,7 @@ insert_clobbers_for_var (gimple_stmt_iterator i, tree var) break; } - if (visited.is_created ()) - visited.dispose (); + delete visited; } /* Detects a __builtin_alloca_with_align with constant size argument. Declares diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c index 9a1ac67bf77..24ed4b4fed6 100644 --- a/gcc/tree-ssa-coalesce.c +++ b/gcc/tree-ssa-coalesce.c @@ -92,7 +92,7 @@ coalesce_pair_hasher::equal (const value_type *p1, const compare_type *p2) && p1->second_element == p2->second_element); } -typedef hash_table <coalesce_pair_hasher> coalesce_table_type; +typedef hash_table<coalesce_pair_hasher> coalesce_table_type; typedef coalesce_table_type::iterator coalesce_iterator_type; @@ -107,7 +107,7 @@ typedef struct cost_one_pair_d typedef struct coalesce_list_d { - coalesce_table_type list; /* Hash table. */ + coalesce_table_type *list; /* Hash table. */ coalesce_pair_p *sorted; /* List when sorted. */ int num_sorted; /* Number in the sorted list. */ cost_one_pair_p cost_one_list;/* Single use coalesces with cost 1. */ @@ -244,7 +244,7 @@ create_coalesce_list (void) size = 40; list = (coalesce_list_p) xmalloc (sizeof (struct coalesce_list_d)); - list->list.create (size); + list->list = new coalesce_table_type (size); list->sorted = NULL; list->num_sorted = 0; list->cost_one_list = NULL; @@ -258,7 +258,8 @@ static inline void delete_coalesce_list (coalesce_list_p cl) { gcc_assert (cl->cost_one_list == NULL); - cl->list.dispose (); + delete cl->list; + cl->list = NULL; free (cl->sorted); gcc_assert (cl->num_sorted == 0); free (cl); @@ -289,7 +290,7 @@ find_coalesce_pair (coalesce_list_p cl, int p1, int p2, bool create) } hash = coalesce_pair_hasher::hash (&p); - slot = cl->list.find_slot_with_hash (&p, hash, create ? INSERT : NO_INSERT); + slot = cl->list->find_slot_with_hash (&p, hash, create ? INSERT : NO_INSERT); if (!slot) return NULL; @@ -372,14 +373,14 @@ compare_pairs (const void *p1, const void *p2) static inline int num_coalesce_pairs (coalesce_list_p cl) { - return cl->list.elements (); + return cl->list->elements (); } /* Iterate over CL using ITER, returning values in PAIR. */ #define FOR_EACH_PARTITION_PAIR(PAIR, ITER, CL) \ - FOR_EACH_HASH_TABLE_ELEMENT ((CL)->list, (PAIR), coalesce_pair_p, (ITER)) + FOR_EACH_HASH_TABLE_ELEMENT (*(CL)->list, (PAIR), coalesce_pair_p, (ITER)) /* Prepare CL for removal of preferred pairs. When finished they are sorted @@ -1267,9 +1268,8 @@ coalesce_ssa_name (void) from the same SSA_NAME_VAR so debug info remains undisturbed. */ if (!optimize) { - hash_table <ssa_name_var_hash> ssa_name_hash; + hash_table<ssa_name_var_hash> ssa_name_hash (10); - ssa_name_hash.create (10); for (i = 1; i < num_ssa_names; i++) { tree a = ssa_name (i); @@ -1303,7 +1303,6 @@ coalesce_ssa_name (void) } } } - ssa_name_hash.dispose (); } if (dump_file && (dump_flags & TDF_DETAILS)) dump_var_map (dump_file, map); diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c index b7ec05b624c..6c581ba7ba5 100644 --- a/gcc/tree-ssa-dom.c +++ b/gcc/tree-ssa-dom.c @@ -223,7 +223,7 @@ expr_elt_hasher::remove (value_type *element) global redundancy elimination). Similarly as we pass through conditionals we record the conditional itself as having either a true or false value in this table. */ -static hash_table <expr_elt_hasher> avail_exprs; +static hash_table<expr_elt_hasher> *avail_exprs; /* Stack of dest,src pairs that need to be restored during finalization. @@ -254,7 +254,8 @@ static struct opt_stats_d opt_stats; static void optimize_stmt (basic_block, gimple_stmt_iterator); static tree lookup_avail_expr (gimple, bool); static hashval_t avail_expr_hash (const void *); -static void htab_statistics (FILE *, hash_table <expr_elt_hasher>); +static void htab_statistics (FILE *, + const hash_table<expr_elt_hasher> &); static void record_cond (cond_equivalence *); static void record_const_or_copy (tree, tree); static void record_equality (tree, tree); @@ -876,7 +877,7 @@ pass_dominator::execute (function *fun) memset (&opt_stats, 0, sizeof (opt_stats)); /* Create our hash tables. */ - avail_exprs.create (1024); + avail_exprs = new hash_table<expr_elt_hasher> (1024); avail_exprs_stack.create (20); const_and_copies_stack.create (20); need_eh_cleanup = BITMAP_ALLOC (NULL); @@ -976,7 +977,8 @@ pass_dominator::execute (function *fun) loop_optimizer_finalize (); /* Delete our main hashtable. */ - avail_exprs.dispose (); + delete avail_exprs; + avail_exprs = NULL; /* Free asserted bitmaps and stacks. */ BITMAP_FREE (need_eh_cleanup); @@ -1070,9 +1072,9 @@ remove_local_expressions_from_table (void) print_expr_hash_elt (dump_file, victim); } - slot = avail_exprs.find_slot_with_hash (victim, victim->hash, NO_INSERT); + slot = avail_exprs->find_slot (victim, NO_INSERT); gcc_assert (slot && *slot == victim); - avail_exprs.clear_slot (slot); + avail_exprs->clear_slot (slot); } } @@ -1351,7 +1353,7 @@ dump_dominator_optimization_stats (FILE *file) fprintf (file, "\nHash table statistics:\n"); fprintf (file, " avail_exprs: "); - htab_statistics (file, avail_exprs); + htab_statistics (file, *avail_exprs); } @@ -1367,7 +1369,7 @@ debug_dominator_optimization_stats (void) /* Dump statistics for the hash table HTAB. */ static void -htab_statistics (FILE *file, hash_table <expr_elt_hasher> htab) +htab_statistics (FILE *file, const hash_table<expr_elt_hasher> &htab) { fprintf (file, "size %ld, %ld elements, %f collision/search ratio\n", (long) htab.size (), @@ -1388,7 +1390,7 @@ record_cond (cond_equivalence *p) initialize_hash_element_from_expr (&p->cond, p->value, element); - slot = avail_exprs.find_slot_with_hash (element, element->hash, INSERT); + slot = avail_exprs->find_slot_with_hash (element, element->hash, INSERT); if (*slot == NULL) { *slot = element; @@ -2551,8 +2553,7 @@ lookup_avail_expr (gimple stmt, bool insert) return NULL_TREE; /* Finally try to find the expression in the main expression hash table. */ - slot = avail_exprs.find_slot_with_hash (&element, element.hash, - (insert ? INSERT : NO_INSERT)); + slot = avail_exprs->find_slot (&element, (insert ? INSERT : NO_INSERT)); if (slot == NULL) { free_expr_hash_elt_contents (&element); diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c index 3cd3613d732..23eaf262c64 100644 --- a/gcc/tree-ssa-live.c +++ b/gcc/tree-ssa-live.c @@ -97,11 +97,10 @@ var_map_base_init (var_map map) { int x, num_part; tree var; - hash_table <tree_int_map_hasher> tree_to_index; struct tree_int_map *m, *mapstorage; num_part = num_var_partitions (map); - tree_to_index.create (num_part); + hash_table<tree_int_map_hasher> tree_to_index (num_part); /* We can have at most num_part entries in the hash tables, so it's enough to allocate so many map elements once, saving some malloc calls. */ @@ -149,7 +148,6 @@ var_map_base_init (var_map map) map->num_basevars = m - mapstorage; free (mapstorage); - tree_to_index. dispose (); } diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c index 6569c0664d2..189da1415b6 100644 --- a/gcc/tree-ssa-loop-im.c +++ b/gcc/tree-ssa-loop-im.c @@ -184,7 +184,7 @@ mem_ref_hasher::equal (const value_type *mem1, const compare_type *obj2) static struct { /* The hash table of memory references accessed in loops. */ - hash_table <mem_ref_hasher> refs; + hash_table<mem_ref_hasher> *refs; /* The list of memory references. */ vec<mem_ref_p> refs_list; @@ -609,7 +609,7 @@ mem_ref_in_stmt (gimple stmt) gcc_assert (!store); hash = iterative_hash_expr (*mem, 0); - ref = memory_accesses.refs.find_with_hash (*mem, hash); + ref = memory_accesses.refs->find_with_hash (*mem, hash); gcc_assert (ref != NULL); return ref; @@ -1485,7 +1485,7 @@ gather_mem_refs_stmt (struct loop *loop, gimple stmt) else { hash = iterative_hash_expr (*mem, 0); - slot = memory_accesses.refs.find_slot_with_hash (*mem, hash, INSERT); + slot = memory_accesses.refs->find_slot_with_hash (*mem, hash, INSERT); if (*slot) { ref = (mem_ref_p) *slot; @@ -2436,7 +2436,7 @@ tree_ssa_lim_initialize (void) alloc_aux_for_edges (0); - memory_accesses.refs.create (100); + memory_accesses.refs = new hash_table<mem_ref_hasher> (100); memory_accesses.refs_list.create (100); /* Allocate a special, unanalyzable mem-ref with ID zero. */ memory_accesses.refs_list.quick_push @@ -2486,7 +2486,8 @@ tree_ssa_lim_finalize (void) bitmap_obstack_release (&lim_bitmap_obstack); pointer_map_destroy (lim_aux_data_map); - memory_accesses.refs.dispose (); + delete memory_accesses.refs; + memory_accesses.refs = NULL; FOR_EACH_VEC_ELT (memory_accesses.refs_list, i, ref) memref_free (ref); diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 7546ff6fe83..58f41c0f32b 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -306,7 +306,7 @@ struct ivopts_data /* The hashtable of loop invariant expressions created by ivopt. */ - hash_table <iv_inv_expr_hasher> inv_expr_tab; + hash_table<iv_inv_expr_hasher> *inv_expr_tab; /* Loop invariant expression id. */ int inv_expr_id; @@ -875,7 +875,7 @@ tree_ssa_iv_optimize_init (struct ivopts_data *data) data->niters = NULL; data->iv_uses.create (20); data->iv_candidates.create (20); - data->inv_expr_tab.create (10); + data->inv_expr_tab = new hash_table<iv_inv_expr_hasher> (10); data->inv_expr_id = 0; decl_rtl_to_reset.create (20); } @@ -3955,7 +3955,7 @@ get_expr_id (struct ivopts_data *data, tree expr) ent.expr = expr; ent.hash = iterative_hash_expr (expr, 0); - slot = data->inv_expr_tab.find_slot (&ent, INSERT); + slot = data->inv_expr_tab->find_slot (&ent, INSERT); if (*slot) return (*slot)->id; @@ -6785,7 +6785,7 @@ free_loop_data (struct ivopts_data *data) decl_rtl_to_reset.truncate (0); - data->inv_expr_tab.empty (); + data->inv_expr_tab->empty (); data->inv_expr_id = 0; } @@ -6803,7 +6803,8 @@ tree_ssa_iv_optimize_finalize (struct ivopts_data *data) decl_rtl_to_reset.release (); data->iv_uses.release (); data->iv_candidates.release (); - data->inv_expr_tab.dispose (); + delete data->inv_expr_tab; + data->inv_expr_tab = NULL; } /* Returns true if the loop body BODY includes any function calls. */ diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c index 54002996cc4..5c11000e97d 100644 --- a/gcc/tree-ssa-phiopt.c +++ b/gcc/tree-ssa-phiopt.c @@ -1466,17 +1466,79 @@ ssa_names_hasher::equal (const value_type *n1, const compare_type *n2) && n1->size == n2->size; } -/* The hash table for remembering what we've seen. */ -static hash_table <ssa_names_hasher> seen_ssa_names; +class nontrapping_dom_walker : public dom_walker +{ +public: + nontrapping_dom_walker (cdi_direction direction, pointer_set_t *ps) + : dom_walker (direction), m_nontrapping (ps), m_seen_ssa_names (128) {} + + virtual void before_dom_children (basic_block); + virtual void after_dom_children (basic_block); + +private: + + /* We see the expression EXP in basic block BB. If it's an interesting + expression (an MEM_REF through an SSA_NAME) possibly insert the + expression into the set NONTRAP or the hash table of seen expressions. + STORE is true if this expression is on the LHS, otherwise it's on + the RHS. */ + void add_or_mark_expr (basic_block, tree, bool); + + pointer_set_t *m_nontrapping; + + /* The hash table for remembering what we've seen. */ + hash_table<ssa_names_hasher> m_seen_ssa_names; +}; + +/* Called by walk_dominator_tree, when entering the block BB. */ +void +nontrapping_dom_walker::before_dom_children (basic_block bb) +{ + edge e; + edge_iterator ei; + gimple_stmt_iterator gsi; + + /* If we haven't seen all our predecessors, clear the hash-table. */ + FOR_EACH_EDGE (e, ei, bb->preds) + if ((((size_t)e->src->aux) & 2) == 0) + { + nt_call_phase++; + break; + } + + /* Mark this BB as being on the path to dominator root and as visited. */ + bb->aux = (void*)(1 | 2); + + /* And walk the statements in order. */ + for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) + { + gimple stmt = gsi_stmt (gsi); + + if (is_gimple_call (stmt) && !nonfreeing_call_p (stmt)) + nt_call_phase++; + else if (gimple_assign_single_p (stmt) && !gimple_has_volatile_ops (stmt)) + { + add_or_mark_expr (bb, gimple_assign_lhs (stmt), true); + add_or_mark_expr (bb, gimple_assign_rhs1 (stmt), false); + } + } +} + +/* Called by walk_dominator_tree, when basic block BB is exited. */ +void +nontrapping_dom_walker::after_dom_children (basic_block bb) +{ + /* This BB isn't on the path to dominator root anymore. */ + bb->aux = (void*)2; +} /* We see the expression EXP in basic block BB. If it's an interesting expression (an MEM_REF through an SSA_NAME) possibly insert the expression into the set NONTRAP or the hash table of seen expressions. STORE is true if this expression is on the LHS, otherwise it's on the RHS. */ -static void -add_or_mark_expr (basic_block bb, tree exp, - struct pointer_set_t *nontrap, bool store) +void +nontrapping_dom_walker::add_or_mark_expr (basic_block bb, tree exp, bool store) { HOST_WIDE_INT size; @@ -1500,7 +1562,7 @@ add_or_mark_expr (basic_block bb, tree exp, map.offset = tree_to_shwi (TREE_OPERAND (exp, 1)); map.size = size; - slot = seen_ssa_names.find_slot (&map, INSERT); + slot = m_seen_ssa_names.find_slot (&map, INSERT); n2bb = *slot; if (n2bb && n2bb->phase >= nt_call_phase) found_bb = n2bb->bb; @@ -1510,7 +1572,7 @@ add_or_mark_expr (basic_block bb, tree exp, then we can't trap. */ if (found_bb && (((size_t)found_bb->aux) & 1) == 1) { - pointer_set_insert (nontrap, exp); + pointer_set_insert (m_nontrapping, exp); } else { @@ -1535,61 +1597,6 @@ add_or_mark_expr (basic_block bb, tree exp, } } -class nontrapping_dom_walker : public dom_walker -{ -public: - nontrapping_dom_walker (cdi_direction direction, pointer_set_t *ps) - : dom_walker (direction), m_nontrapping (ps) {} - - virtual void before_dom_children (basic_block); - virtual void after_dom_children (basic_block); - -private: - pointer_set_t *m_nontrapping; -}; - -/* Called by walk_dominator_tree, when entering the block BB. */ -void -nontrapping_dom_walker::before_dom_children (basic_block bb) -{ - edge e; - edge_iterator ei; - gimple_stmt_iterator gsi; - - /* If we haven't seen all our predecessors, clear the hash-table. */ - FOR_EACH_EDGE (e, ei, bb->preds) - if ((((size_t)e->src->aux) & 2) == 0) - { - nt_call_phase++; - break; - } - - /* Mark this BB as being on the path to dominator root and as visited. */ - bb->aux = (void*)(1 | 2); - - /* And walk the statements in order. */ - for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) - { - gimple stmt = gsi_stmt (gsi); - - if (is_gimple_call (stmt) && !nonfreeing_call_p (stmt)) - nt_call_phase++; - else if (gimple_assign_single_p (stmt) && !gimple_has_volatile_ops (stmt)) - { - add_or_mark_expr (bb, gimple_assign_lhs (stmt), m_nontrapping, true); - add_or_mark_expr (bb, gimple_assign_rhs1 (stmt), m_nontrapping, false); - } - } -} - -/* Called by walk_dominator_tree, when basic block BB is exited. */ -void -nontrapping_dom_walker::after_dom_children (basic_block bb) -{ - /* This BB isn't on the path to dominator root anymore. */ - bb->aux = (void*)2; -} - /* This is the entry point of gathering non trapping memory accesses. It will do a dominator walk over the whole function, and it will make use of the bb->aux pointers. It returns a set of trees @@ -1599,7 +1606,6 @@ get_non_trapping (void) { nt_call_phase = 0; pointer_set_t *nontrap = pointer_set_create (); - seen_ssa_names.create (128); /* We're going to do a dominator walk, so ensure that we have dominance information. */ calculate_dominance_info (CDI_DOMINATORS); @@ -1607,8 +1613,6 @@ get_non_trapping (void) nontrapping_dom_walker (CDI_DOMINATORS, nontrap) .walk (cfun->cfg->x_entry_block_ptr); - seen_ssa_names.dispose (); - clear_aux_for_blocks (); return nontrap; } diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index 686f1076d3b..74238decfef 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -253,7 +253,7 @@ static unsigned int next_expression_id; /* Mapping from expression to id number we can use in bitmap sets. */ static vec<pre_expr> expressions; -static hash_table <pre_expr_d> expression_to_id; +static hash_table<pre_expr_d> *expression_to_id; static vec<unsigned> name_to_id; /* Allocate an expression id for EXPR. */ @@ -280,7 +280,7 @@ alloc_expression_id (pre_expr expr) } else { - slot = expression_to_id.find_slot (expr, INSERT); + slot = expression_to_id->find_slot (expr, INSERT); gcc_assert (!*slot); *slot = expr; } @@ -309,7 +309,7 @@ lookup_expression_id (const pre_expr expr) } else { - slot = expression_to_id.find_slot (expr, NO_INSERT); + slot = expression_to_id->find_slot (expr, NO_INSERT); if (!slot) return 0; return ((pre_expr)*slot)->id; @@ -542,7 +542,7 @@ expr_pred_trans_d::equal (const value_type *ve1, /* The phi_translate_table caches phi translations for a given expression and predecessor. */ -static hash_table <expr_pred_trans_d> phi_translate_table; +static hash_table<expr_pred_trans_d> *phi_translate_table; /* Add the tuple mapping from {expression E, basic block PRED} to the phi translation table and return whether it pre-existed. */ @@ -557,7 +557,7 @@ phi_trans_add (expr_pred_trans_t *entry, pre_expr e, basic_block pred) tem.e = e; tem.pred = pred; tem.hashcode = hash; - slot = phi_translate_table.find_slot_with_hash (&tem, hash, INSERT); + slot = phi_translate_table->find_slot_with_hash (&tem, hash, INSERT); if (*slot) { *entry = *slot; @@ -1783,7 +1783,7 @@ phi_translate (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, else /* Remove failed translations again, they cause insert iteration to not pick up new opportunities reliably. */ - phi_translate_table.remove_elt_with_hash (slot, slot->hashcode); + phi_translate_table->remove_elt_with_hash (slot, slot->hashcode); } return phitrans; @@ -4711,8 +4711,8 @@ init_pre (void) calculate_dominance_info (CDI_DOMINATORS); bitmap_obstack_initialize (&grand_bitmap_obstack); - phi_translate_table.create (5110); - expression_to_id.create (num_ssa_names * 3); + phi_translate_table = new hash_table<expr_pred_trans_d> (5110); + expression_to_id = new hash_table<pre_expr_d> (num_ssa_names * 3); bitmap_set_pool = create_alloc_pool ("Bitmap sets", sizeof (struct bitmap_set), 30); pre_expr_pool = create_alloc_pool ("pre_expr nodes", @@ -4738,8 +4738,10 @@ fini_pre () bitmap_obstack_release (&grand_bitmap_obstack); free_alloc_pool (bitmap_set_pool); free_alloc_pool (pre_expr_pool); - phi_translate_table.dispose (); - expression_to_id.dispose (); + delete phi_translate_table; + phi_translate_table = NULL; + delete expression_to_id; + expression_to_id = NULL; name_to_id.release (); free_aux_for_blocks (); diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index 3d811f06893..4d0d6c21b06 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -1405,7 +1405,6 @@ undistribute_ops_list (enum tree_code opcode, unsigned nr_candidates, nr_candidates2; sbitmap_iterator sbi0; vec<operand_entry_t> *subops; - hash_table <oecount_hasher> ctable; bool changed = false; int next_oecount_id = 0; @@ -1453,7 +1452,9 @@ undistribute_ops_list (enum tree_code opcode, /* Build linearized sub-operand lists and the counting table. */ cvec.create (0); - ctable.create (15); + + hash_table<oecount_hasher> ctable (15); + /* ??? Macro arguments cannot have multi-argument template types in them. This typedef is needed to workaround that limitation. */ typedef vec<operand_entry_t> vec_operand_entry_t_heap; @@ -1492,7 +1493,6 @@ undistribute_ops_list (enum tree_code opcode, } } } - ctable.dispose (); /* Sort the counting table. */ cvec.qsort (oecount_cmp); diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index b949bfa725d..139ac3bbc72 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -139,7 +139,7 @@ vn_nary_op_hasher::equal (const value_type *vno1, const compare_type *vno2) return vn_nary_op_eq (vno1, vno2); } -typedef hash_table <vn_nary_op_hasher> vn_nary_op_table_type; +typedef hash_table<vn_nary_op_hasher> vn_nary_op_table_type; typedef vn_nary_op_table_type::iterator vn_nary_op_iterator_type; @@ -181,7 +181,7 @@ vn_phi_hasher::remove (value_type *phi) phi->phiargs.release (); } -typedef hash_table <vn_phi_hasher> vn_phi_table_type; +typedef hash_table<vn_phi_hasher> vn_phi_table_type; typedef vn_phi_table_type::iterator vn_phi_iterator_type; @@ -245,7 +245,7 @@ vn_reference_hasher::remove (value_type *v) free_reference (v); } -typedef hash_table <vn_reference_hasher> vn_reference_table_type; +typedef hash_table<vn_reference_hasher> vn_reference_table_type; typedef vn_reference_table_type::iterator vn_reference_iterator_type; @@ -253,9 +253,9 @@ typedef vn_reference_table_type::iterator vn_reference_iterator_type; typedef struct vn_tables_s { - vn_nary_op_table_type nary; - vn_phi_table_type phis; - vn_reference_table_type references; + vn_nary_op_table_type *nary; + vn_phi_table_type *phis; + vn_reference_table_type *references; struct obstack nary_obstack; alloc_pool phis_pool; alloc_pool references_pool; @@ -291,7 +291,7 @@ vn_constant_hasher::equal (const value_type *vc1, const compare_type *vc2) return vn_constant_eq_with_type (vc1->constant, vc2->constant); } -static hash_table <vn_constant_hasher> constant_to_value_id; +static hash_table<vn_constant_hasher> *constant_to_value_id; static bitmap constant_value_ids; @@ -552,7 +552,7 @@ get_constant_value_id (tree constant) vc.hashcode = vn_hash_constant_with_type (constant); vc.constant = constant; - slot = constant_to_value_id.find_slot_with_hash (&vc, vc.hashcode, NO_INSERT); + slot = constant_to_value_id->find_slot (&vc, NO_INSERT); if (slot) return (*slot)->value_id; return 0; @@ -570,7 +570,7 @@ get_or_alloc_constant_value_id (tree constant) vc.hashcode = vn_hash_constant_with_type (constant); vc.constant = constant; - slot = constant_to_value_id.find_slot_with_hash (&vc, vc.hashcode, INSERT); + slot = constant_to_value_id->find_slot (&vc, INSERT); if (*slot) return (*slot)->value_id; @@ -1474,9 +1474,9 @@ vn_reference_lookup_1 (vn_reference_t vr, vn_reference_t *vnresult) hashval_t hash; hash = vr->hashcode; - slot = current_info->references.find_slot_with_hash (vr, hash, NO_INSERT); + slot = current_info->references->find_slot_with_hash (vr, hash, NO_INSERT); if (!slot && current_info == optimistic_info) - slot = valid_info->references.find_slot_with_hash (vr, hash, NO_INSERT); + slot = valid_info->references->find_slot_with_hash (vr, hash, NO_INSERT); if (slot) { if (vnresult) @@ -1519,9 +1519,9 @@ vn_reference_lookup_2 (ao_ref *op ATTRIBUTE_UNUSED, tree vuse, vr->hashcode = vr->hashcode + SSA_NAME_VERSION (vr->vuse); hash = vr->hashcode; - slot = current_info->references.find_slot_with_hash (vr, hash, NO_INSERT); + slot = current_info->references->find_slot_with_hash (vr, hash, NO_INSERT); if (!slot && current_info == optimistic_info) - slot = valid_info->references.find_slot_with_hash (vr, hash, NO_INSERT); + slot = valid_info->references->find_slot_with_hash (vr, hash, NO_INSERT); if (slot) return *slot; @@ -2173,8 +2173,8 @@ vn_reference_insert (tree op, tree result, tree vuse, tree vdef) vr1->result = TREE_CODE (result) == SSA_NAME ? SSA_VAL (result) : result; vr1->result_vdef = vdef; - slot = current_info->references.find_slot_with_hash (vr1, vr1->hashcode, - INSERT); + slot = current_info->references->find_slot_with_hash (vr1, vr1->hashcode, + INSERT); /* Because we lookup stores using vuses, and value number failures using the vdefs (see visit_reference_op_store for how and why), @@ -2216,8 +2216,8 @@ vn_reference_insert_pieces (tree vuse, alias_set_type set, tree type, result = SSA_VAL (result); vr1->result = result; - slot = current_info->references.find_slot_with_hash (vr1, vr1->hashcode, - INSERT); + slot = current_info->references->find_slot_with_hash (vr1, vr1->hashcode, + INSERT); /* At this point we should have all the things inserted that we have seen before, and we should never try inserting something that @@ -2386,9 +2386,11 @@ vn_nary_op_lookup_1 (vn_nary_op_t vno, vn_nary_op_t *vnresult) *vnresult = NULL; vno->hashcode = vn_nary_op_compute_hash (vno); - slot = current_info->nary.find_slot_with_hash (vno, vno->hashcode, NO_INSERT); + slot = current_info->nary->find_slot_with_hash (vno, vno->hashcode, + NO_INSERT); if (!slot && current_info == optimistic_info) - slot = valid_info->nary.find_slot_with_hash (vno, vno->hashcode, NO_INSERT); + slot = valid_info->nary->find_slot_with_hash (vno, vno->hashcode, + NO_INSERT); if (!slot) return NULL_TREE; if (vnresult) @@ -2471,7 +2473,7 @@ alloc_vn_nary_op (unsigned int length, tree result, unsigned int value_id) VNO->HASHCODE first. */ static vn_nary_op_t -vn_nary_op_insert_into (vn_nary_op_t vno, vn_nary_op_table_type table, +vn_nary_op_insert_into (vn_nary_op_t vno, vn_nary_op_table_type *table, bool compute_hash) { vn_nary_op_s **slot; @@ -2479,7 +2481,7 @@ vn_nary_op_insert_into (vn_nary_op_t vno, vn_nary_op_table_type table, if (compute_hash) vno->hashcode = vn_nary_op_compute_hash (vno); - slot = table.find_slot_with_hash (vno, vno->hashcode, INSERT); + slot = table->find_slot_with_hash (vno, vno->hashcode, INSERT); gcc_assert (!*slot); *slot = vno; @@ -2614,9 +2616,11 @@ vn_phi_lookup (gimple phi) vp1.phiargs = shared_lookup_phiargs; vp1.block = gimple_bb (phi); vp1.hashcode = vn_phi_compute_hash (&vp1); - slot = current_info->phis.find_slot_with_hash (&vp1, vp1.hashcode, NO_INSERT); + slot = current_info->phis->find_slot_with_hash (&vp1, vp1.hashcode, + NO_INSERT); if (!slot && current_info == optimistic_info) - slot = valid_info->phis.find_slot_with_hash (&vp1, vp1.hashcode, NO_INSERT); + slot = valid_info->phis->find_slot_with_hash (&vp1, vp1.hashcode, + NO_INSERT); if (!slot) return NULL_TREE; return (*slot)->result; @@ -2647,7 +2651,7 @@ vn_phi_insert (gimple phi, tree result) vp1->result = result; vp1->hashcode = vn_phi_compute_hash (vp1); - slot = current_info->phis.find_slot_with_hash (vp1, vp1->hashcode, INSERT); + slot = current_info->phis->find_slot_with_hash (vp1, vp1->hashcode, INSERT); /* Because we iterate over phi operations more than once, it's possible the slot might already exist here, hence no assert.*/ @@ -2886,8 +2890,8 @@ visit_reference_op_call (tree lhs, gimple stmt) vr2->hashcode = vr1.hashcode; vr2->result = lhs; vr2->result_vdef = vdef; - slot = current_info->references.find_slot_with_hash (vr2, vr2->hashcode, - INSERT); + slot = current_info->references->find_slot_with_hash (vr2, vr2->hashcode, + INSERT); if (*slot) free_reference (*slot); *slot = vr2; @@ -3748,7 +3752,7 @@ copy_phi (vn_phi_t ophi, vn_tables_t info) vn_phi_s **slot; memcpy (phi, ophi, sizeof (*phi)); ophi->phiargs.create (0); - slot = info->phis.find_slot_with_hash (phi, phi->hashcode, INSERT); + slot = info->phis->find_slot_with_hash (phi, phi->hashcode, INSERT); gcc_assert (!*slot); *slot = phi; } @@ -3763,7 +3767,7 @@ copy_reference (vn_reference_t oref, vn_tables_t info) ref = (vn_reference_t) pool_alloc (info->references_pool); memcpy (ref, oref, sizeof (*ref)); oref->operands.create (0); - slot = info->references.find_slot_with_hash (ref, ref->hashcode, INSERT); + slot = info->references->find_slot_with_hash (ref, ref->hashcode, INSERT); if (*slot) free_reference (*slot); *slot = ref; @@ -3820,9 +3824,9 @@ process_scc (vec<tree> scc) /* As we are value-numbering optimistically we have to clear the expression tables and the simplified expressions in each iteration until we converge. */ - optimistic_info->nary.empty (); - optimistic_info->phis.empty (); - optimistic_info->references.empty (); + optimistic_info->nary->empty (); + optimistic_info->phis->empty (); + optimistic_info->references->empty (); obstack_free (&optimistic_info->nary_obstack, NULL); gcc_obstack_init (&optimistic_info->nary_obstack); empty_alloc_pool (optimistic_info->phis_pool); @@ -3839,11 +3843,11 @@ process_scc (vec<tree> scc) /* Finally, copy the contents of the no longer used optimistic table to the valid table. */ - FOR_EACH_HASH_TABLE_ELEMENT (optimistic_info->nary, nary, vn_nary_op_t, hin) + FOR_EACH_HASH_TABLE_ELEMENT (*optimistic_info->nary, nary, vn_nary_op_t, hin) copy_nary (nary, valid_info); - FOR_EACH_HASH_TABLE_ELEMENT (optimistic_info->phis, phi, vn_phi_t, hip) + FOR_EACH_HASH_TABLE_ELEMENT (*optimistic_info->phis, phi, vn_phi_t, hip) copy_phi (phi, valid_info); - FOR_EACH_HASH_TABLE_ELEMENT (optimistic_info->references, + FOR_EACH_HASH_TABLE_ELEMENT (*optimistic_info->references, ref, vn_reference_t, hir) copy_reference (ref, valid_info); @@ -3998,9 +4002,9 @@ continue_walking: static void allocate_vn_table (vn_tables_t table) { - table->phis.create (23); - table->nary.create (23); - table->references.create (23); + table->phis = new vn_phi_table_type (23); + table->nary = new vn_nary_op_table_type (23); + table->references = new vn_reference_table_type (23); gcc_obstack_init (&table->nary_obstack); table->phis_pool = create_alloc_pool ("VN phis", @@ -4016,9 +4020,12 @@ allocate_vn_table (vn_tables_t table) static void free_vn_table (vn_tables_t table) { - table->phis.dispose (); - table->nary.dispose (); - table->references.dispose (); + delete table->phis; + table->phis = NULL; + delete table->nary; + table->nary = NULL; + delete table->references; + table->references = NULL; obstack_free (&table->nary_obstack, NULL); free_alloc_pool (table->phis_pool); free_alloc_pool (table->references_pool); @@ -4033,7 +4040,7 @@ init_scc_vn (void) calculate_dominance_info (CDI_DOMINATORS); sccstack.create (0); - constant_to_value_id.create (23); + constant_to_value_id = new hash_table<vn_constant_hasher> (23); constant_value_ids = BITMAP_ALLOC (NULL); @@ -4090,7 +4097,8 @@ free_scc_vn (void) { size_t i; - constant_to_value_id.dispose (); + delete constant_to_value_id; + constant_to_value_id = NULL; BITMAP_FREE (constant_value_ids); shared_lookup_phiargs.release (); shared_lookup_references.release (); @@ -4141,13 +4149,14 @@ set_hashtable_value_ids (void) /* Now set the value ids of the things we had put in the hash table. */ - FOR_EACH_HASH_TABLE_ELEMENT (valid_info->nary, vno, vn_nary_op_t, hin) + FOR_EACH_HASH_TABLE_ELEMENT (*valid_info->nary, vno, vn_nary_op_t, hin) set_value_id_for_result (vno->result, &vno->value_id); - FOR_EACH_HASH_TABLE_ELEMENT (valid_info->phis, vp, vn_phi_t, hip) + FOR_EACH_HASH_TABLE_ELEMENT (*valid_info->phis, vp, vn_phi_t, hip) set_value_id_for_result (vp->result, &vp->value_id); - FOR_EACH_HASH_TABLE_ELEMENT (valid_info->references, vr, vn_reference_t, hir) + FOR_EACH_HASH_TABLE_ELEMENT (*valid_info->references, vr, vn_reference_t, + hir) set_value_id_for_result (vr->result, &vr->value_id); } diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c index bc3d712796a..b452d9d6d4c 100644 --- a/gcc/tree-ssa-strlen.c +++ b/gcc/tree-ssa-strlen.c @@ -158,7 +158,7 @@ stridxlist_hasher::equal (const value_type *v, const compare_type *c) /* Hash table for mapping decls to a chained list of offset -> idx mappings. */ -static hash_table <stridxlist_hasher> decl_to_stridxlist_htab; +static hash_table<stridxlist_hasher> *decl_to_stridxlist_htab; /* Obstack for struct stridxlist and struct decl_stridxlist_map. */ static struct obstack stridx_obstack; @@ -183,7 +183,7 @@ get_addr_stridx (tree exp) struct stridxlist *list; tree base; - if (!decl_to_stridxlist_htab.is_created ()) + if (!decl_to_stridxlist_htab) return 0; base = get_addr_base_and_unit_offset (exp, &off); @@ -191,7 +191,7 @@ get_addr_stridx (tree exp) return 0; ent.base.from = base; - e = decl_to_stridxlist_htab.find_with_hash (&ent, DECL_UID (base)); + e = decl_to_stridxlist_htab->find_with_hash (&ent, DECL_UID (base)); if (e == NULL) return 0; @@ -279,14 +279,14 @@ addr_stridxptr (tree exp) if (base == NULL_TREE || !DECL_P (base)) return NULL; - if (!decl_to_stridxlist_htab.is_created ()) + if (!decl_to_stridxlist_htab) { - decl_to_stridxlist_htab.create (64); + decl_to_stridxlist_htab = new hash_table<stridxlist_hasher> (64); gcc_obstack_init (&stridx_obstack); } ent.base.from = base; - slot = decl_to_stridxlist_htab.find_slot_with_hash (&ent, DECL_UID (base), - INSERT); + slot = decl_to_stridxlist_htab->find_slot_with_hash (&ent, DECL_UID (base), + INSERT); if (*slot) { int i; @@ -2106,10 +2106,11 @@ pass_strlen::execute (function *fun) ssa_ver_to_stridx.release (); free_alloc_pool (strinfo_pool); - if (decl_to_stridxlist_htab.is_created ()) + if (decl_to_stridxlist_htab) { obstack_free (&stridx_obstack, NULL); - decl_to_stridxlist_htab.dispose (); + delete decl_to_stridxlist_htab; + decl_to_stridxlist_htab = NULL; } laststmt.stmt = NULL; laststmt.len = NULL_TREE; diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index 99e97d67a85..0472239f5b0 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -1927,25 +1927,26 @@ equiv_class_hasher::equal (const value_type *eql1, const compare_type *eql2) /* A hashtable for mapping a bitmap of labels->pointer equivalence classes. */ -static hash_table <equiv_class_hasher> pointer_equiv_class_table; +static hash_table<equiv_class_hasher> *pointer_equiv_class_table; /* A hashtable for mapping a bitmap of labels->location equivalence classes. */ -static hash_table <equiv_class_hasher> location_equiv_class_table; +static hash_table<equiv_class_hasher> *location_equiv_class_table; /* Lookup a equivalence class in TABLE by the bitmap of LABELS with hash HAS it contains. Sets *REF_LABELS to the bitmap LABELS is equivalent to. */ static equiv_class_label * -equiv_class_lookup_or_add (hash_table <equiv_class_hasher> table, bitmap labels) +equiv_class_lookup_or_add (hash_table<equiv_class_hasher> *table, + bitmap labels) { equiv_class_label **slot; equiv_class_label ecl; ecl.labels = labels; ecl.hashcode = bitmap_hash (labels); - slot = table.find_slot_with_hash (&ecl, ecl.hashcode, INSERT); + slot = table->find_slot (&ecl, INSERT); if (!*slot) { *slot = XNEW (struct equiv_class_label); @@ -2281,8 +2282,9 @@ perform_var_substitution (constraint_graph_t graph) struct scc_info *si = init_scc_info (size); bitmap_obstack_initialize (&iteration_obstack); - pointer_equiv_class_table.create (511); - location_equiv_class_table.create (511); + pointer_equiv_class_table = new hash_table<equiv_class_hasher> (511); + location_equiv_class_table + = new hash_table<equiv_class_hasher> (511); pointer_equiv_class = 1; location_equiv_class = 1; @@ -2415,8 +2417,10 @@ free_var_substitution_info (struct scc_info *si) free (graph->points_to); free (graph->eq_rep); sbitmap_free (graph->direct_nodes); - pointer_equiv_class_table.dispose (); - location_equiv_class_table.dispose (); + delete pointer_equiv_class_table; + pointer_equiv_class_table = NULL; + delete location_equiv_class_table; + location_equiv_class_table = NULL; bitmap_obstack_release (&iteration_obstack); } @@ -5974,7 +5978,7 @@ shared_bitmap_hasher::equal (const value_type *sbi1, const compare_type *sbi2) /* Shared_bitmap hashtable. */ -static hash_table <shared_bitmap_hasher> shared_bitmap_table; +static hash_table<shared_bitmap_hasher> *shared_bitmap_table; /* Lookup a bitmap in the shared bitmap hashtable, and return an already existing instance if there is one, NULL otherwise. */ @@ -5988,8 +5992,7 @@ shared_bitmap_lookup (bitmap pt_vars) sbi.pt_vars = pt_vars; sbi.hashcode = bitmap_hash (pt_vars); - slot = shared_bitmap_table.find_slot_with_hash (&sbi, sbi.hashcode, - NO_INSERT); + slot = shared_bitmap_table->find_slot (&sbi, NO_INSERT); if (!slot) return NULL; else @@ -6008,7 +6011,7 @@ shared_bitmap_add (bitmap pt_vars) sbi->pt_vars = pt_vars; sbi->hashcode = bitmap_hash (pt_vars); - slot = shared_bitmap_table.find_slot_with_hash (sbi, sbi->hashcode, INSERT); + slot = shared_bitmap_table->find_slot (sbi, INSERT); gcc_assert (!*slot); *slot = sbi; } @@ -6682,7 +6685,7 @@ init_alias_vars (void) call_stmt_vars = pointer_map_create (); memset (&stats, 0, sizeof (stats)); - shared_bitmap_table.create (511); + shared_bitmap_table = new hash_table<shared_bitmap_hasher> (511); init_base_vars (); gcc_obstack_init (&fake_var_decl_obstack); @@ -6930,7 +6933,8 @@ delete_points_to_sets (void) { unsigned int i; - shared_bitmap_table.dispose (); + delete shared_bitmap_table; + shared_bitmap_table = NULL; if (dump_file && (dump_flags & TDF_STATS)) fprintf (dump_file, "Points to sets created:%d\n", stats.points_to_sets_created); diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c index 65b5a4e4420..7245223ae8c 100644 --- a/gcc/tree-ssa-tail-merge.c +++ b/gcc/tree-ssa-tail-merge.c @@ -643,7 +643,7 @@ same_succ_reset (same_succ same) same->succ_flags.truncate (0); } -static hash_table <same_succ_def> same_succ_htab; +static hash_table<same_succ_def> *same_succ_htab; /* Array that is used to store the edge flags for a successor. */ @@ -664,7 +664,7 @@ extern void debug_same_succ (void); DEBUG_FUNCTION void debug_same_succ ( void) { - same_succ_htab.traverse <FILE *, ssa_same_succ_print_traverse> (stderr); + same_succ_htab->traverse <FILE *, ssa_same_succ_print_traverse> (stderr); } @@ -731,7 +731,7 @@ find_same_succ_bb (basic_block bb, same_succ *same_p) same->hashval = same_succ_hash (same); - slot = same_succ_htab.find_slot_with_hash (same, same->hashval, INSERT); + slot = same_succ_htab->find_slot_with_hash (same, same->hashval, INSERT); if (*slot == NULL) { *slot = same; @@ -774,7 +774,7 @@ static void init_worklist (void) { alloc_aux_for_blocks (sizeof (struct aux_bb_info)); - same_succ_htab.create (n_basic_blocks_for_fn (cfun)); + same_succ_htab = new hash_table<same_succ_def> (n_basic_blocks_for_fn (cfun)); same_succ_edge_flags = XCNEWVEC (int, last_basic_block_for_fn (cfun)); deleted_bbs = BITMAP_ALLOC (NULL); deleted_bb_preds = BITMAP_ALLOC (NULL); @@ -794,7 +794,8 @@ static void delete_worklist (void) { free_aux_for_blocks (); - same_succ_htab.dispose (); + delete same_succ_htab; + same_succ_htab = NULL; XDELETEVEC (same_succ_edge_flags); same_succ_edge_flags = NULL; BITMAP_FREE (deleted_bbs); @@ -824,7 +825,7 @@ same_succ_flush_bb (basic_block bb) same_succ same = BB_SAME_SUCC (bb); BB_SAME_SUCC (bb) = NULL; if (bitmap_single_bit_set_p (same->bbs)) - same_succ_htab.remove_elt_with_hash (same, same->hashval); + same_succ_htab->remove_elt_with_hash (same, same->hashval); else bitmap_clear_bit (same->bbs, bb->index); } @@ -1714,7 +1715,7 @@ tail_merge_optimize (unsigned int todo) if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "htab collision / search: %f\n", - same_succ_htab.collisions ()); + same_succ_htab->collisions ()); if (nr_bbs_removed_total > 0) { diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c index fa31613d1ad..02cf42c0da0 100644 --- a/gcc/tree-ssa-threadupdate.c +++ b/gcc/tree-ssa-threadupdate.c @@ -311,7 +311,7 @@ create_block_for_threading (basic_block bb, /* Main data structure to hold information for duplicates of BB. */ -static hash_table <redirection_data> redirection_data; +static hash_table<redirection_data> *redirection_data; /* Given an outgoing edge E lookup and return its entry in our hash table. @@ -334,7 +334,7 @@ lookup_redirection_data (edge e, enum insert_option insert) elt->dup_blocks[1] = NULL; elt->incoming_edges = NULL; - slot = redirection_data.find_slot (elt, insert); + slot = redirection_data->find_slot (elt, insert); /* This will only happen if INSERT is false and the entry is not in the hash table. */ @@ -850,7 +850,8 @@ thread_block_1 (basic_block bb, bool noloop_only, bool joiners) use a hash table. For normal code there should be no noticeable difference. However, if we have a block with a large number of incoming and outgoing edges such linear searches can get expensive. */ - redirection_data.create (EDGE_COUNT (bb->succs)); + redirection_data + = new hash_table<struct redirection_data> (EDGE_COUNT (bb->succs)); /* If we thread the latch of the loop to its exit, the loop ceases to exist. Make sure we do not restrict ourselves in order to preserve @@ -961,7 +962,7 @@ thread_block_1 (basic_block bb, bool noloop_only, bool joiners) local_info.template_block = NULL; local_info.bb = bb; local_info.jumps_threaded = false; - redirection_data.traverse <ssa_local_info_t *, ssa_create_duplicates> + redirection_data->traverse <ssa_local_info_t *, ssa_create_duplicates> (&local_info); /* The template does not have an outgoing edge. Create that outgoing @@ -969,18 +970,19 @@ thread_block_1 (basic_block bb, bool noloop_only, bool joiners) We do this after creating all the duplicates to avoid creating unnecessary edges. */ - redirection_data.traverse <ssa_local_info_t *, ssa_fixup_template_block> + redirection_data->traverse <ssa_local_info_t *, ssa_fixup_template_block> (&local_info); /* The hash table traversals above created the duplicate blocks (and the statements within the duplicate blocks). This loop creates PHI nodes for the duplicated blocks and redirects the incoming edges into BB to reach the duplicates of BB. */ - redirection_data.traverse <ssa_local_info_t *, ssa_redirect_edges> + redirection_data->traverse <ssa_local_info_t *, ssa_redirect_edges> (&local_info); /* Done with this block. Clear REDIRECTION_DATA. */ - redirection_data.dispose (); + delete redirection_data; + redirection_data = NULL; if (noloop_only && bb == bb->loop_father->header) diff --git a/gcc/tree-ssa-uncprop.c b/gcc/tree-ssa-uncprop.c index 7342c9d1514..81d30851f53 100644 --- a/gcc/tree-ssa-uncprop.c +++ b/gcc/tree-ssa-uncprop.c @@ -321,7 +321,7 @@ val_ssa_equiv_hasher::remove (value_type *elt) /* Global hash table implementing a mapping from invariant values to a list of SSA_NAMEs which have the same value. We might be able to reuse tree-vn for this code. */ -static hash_table <val_ssa_equiv_hasher> val_ssa_equiv; +static hash_table<val_ssa_equiv_hasher> *val_ssa_equiv; static void uncprop_into_successor_phis (basic_block); @@ -336,7 +336,7 @@ remove_equivalence (tree value) an_equiv_elt.value = value; an_equiv_elt.equivalences.create (0); - slot = val_ssa_equiv.find_slot (&an_equiv_elt, NO_INSERT); + slot = val_ssa_equiv->find_slot (&an_equiv_elt, NO_INSERT); an_equiv_elt_p = *slot; an_equiv_elt_p->equivalences.pop (); @@ -354,7 +354,7 @@ record_equiv (tree value, tree equivalence) an_equiv_elt_p->value = value; an_equiv_elt_p->equivalences.create (0); - slot = val_ssa_equiv.find_slot (an_equiv_elt_p, INSERT); + slot = val_ssa_equiv->find_slot (an_equiv_elt_p, INSERT); if (*slot == NULL) *slot = an_equiv_elt_p; @@ -446,7 +446,7 @@ uncprop_into_successor_phis (basic_block bb) /* Lookup this argument's value in the hash table. */ an_equiv_elt.value = arg; an_equiv_elt.equivalences.create (0); - slot = val_ssa_equiv.find_slot (&an_equiv_elt, NO_INSERT); + slot = val_ssa_equiv->find_slot (&an_equiv_elt, NO_INSERT); if (slot) { @@ -578,7 +578,7 @@ pass_uncprop::execute (function *fun) associate_equivalences_with_edges (); /* Create our global data structures. */ - val_ssa_equiv.create (1024); + val_ssa_equiv = new hash_table<val_ssa_equiv_hasher> (1024); /* We're going to do a dominator walk, so ensure that we have dominance information. */ @@ -590,7 +590,8 @@ pass_uncprop::execute (function *fun) /* we just need to empty elements out of the hash table, and cleanup the AUX field on the edges. */ - val_ssa_equiv.dispose (); + delete val_ssa_equiv; + val_ssa_equiv = NULL; FOR_EACH_BB_FN (bb, fun) { edge e; diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index d5cd9eca2fe..93a14cf4db2 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -1068,7 +1068,7 @@ vect_peeling_hash_insert (loop_vec_info loop_vinfo, struct data_reference *dr, bool supportable_dr_alignment = vect_supportable_dr_alignment (dr, true); elem.npeel = npeel; - slot = LOOP_VINFO_PEELING_HTAB (loop_vinfo).find (&elem); + slot = LOOP_VINFO_PEELING_HTAB (loop_vinfo)->find (&elem); if (slot) slot->count++; else @@ -1077,7 +1077,8 @@ vect_peeling_hash_insert (loop_vec_info loop_vinfo, struct data_reference *dr, slot->npeel = npeel; slot->dr = dr; slot->count = 1; - new_slot = LOOP_VINFO_PEELING_HTAB (loop_vinfo).find_slot (slot, INSERT); + new_slot + = LOOP_VINFO_PEELING_HTAB (loop_vinfo)->find_slot (slot, INSERT); *new_slot = slot; } @@ -1197,15 +1198,15 @@ vect_peeling_hash_choose_best_peeling (loop_vec_info loop_vinfo, res.inside_cost = INT_MAX; res.outside_cost = INT_MAX; LOOP_VINFO_PEELING_HTAB (loop_vinfo) - .traverse <_vect_peel_extended_info *, - vect_peeling_hash_get_lowest_cost> (&res); + ->traverse <_vect_peel_extended_info *, + vect_peeling_hash_get_lowest_cost> (&res); } else { res.peel_info.count = 0; LOOP_VINFO_PEELING_HTAB (loop_vinfo) - .traverse <_vect_peel_extended_info *, - vect_peeling_hash_get_most_frequent> (&res); + ->traverse <_vect_peel_extended_info *, + vect_peeling_hash_get_most_frequent> (&res); } *npeel = res.peel_info.npeel; @@ -1397,8 +1398,9 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo) size_zero_node) < 0; /* Save info about DR in the hash table. */ - if (!LOOP_VINFO_PEELING_HTAB (loop_vinfo).is_created ()) - LOOP_VINFO_PEELING_HTAB (loop_vinfo).create (1); + if (!LOOP_VINFO_PEELING_HTAB (loop_vinfo)) + LOOP_VINFO_PEELING_HTAB (loop_vinfo) + = new hash_table<peel_info_hasher> (1); vectype = STMT_VINFO_VECTYPE (stmt_info); nelements = TYPE_VECTOR_SUBPARTS (vectype); diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c index 1f6ac1a348b..7cb9787a917 100644 --- a/gcc/tree-vect-loop.c +++ b/gcc/tree-vect-loop.c @@ -1031,8 +1031,8 @@ destroy_loop_vec_info (loop_vec_info loop_vinfo, bool clean_stmts) LOOP_VINFO_REDUCTIONS (loop_vinfo).release (); LOOP_VINFO_REDUCTION_CHAINS (loop_vinfo).release (); - if (LOOP_VINFO_PEELING_HTAB (loop_vinfo).is_created ()) - LOOP_VINFO_PEELING_HTAB (loop_vinfo).dispose (); + delete LOOP_VINFO_PEELING_HTAB (loop_vinfo); + LOOP_VINFO_PEELING_HTAB (loop_vinfo) = NULL; destroy_cost_data (LOOP_VINFO_TARGET_COST_DATA (loop_vinfo)); diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c index f10e6218273..4d30cfa6a77 100644 --- a/gcc/tree-vectorizer.c +++ b/gcc/tree-vectorizer.c @@ -157,7 +157,7 @@ simd_array_to_simduid::equal (const value_type *p1, const value_type *p2) into their corresponding constants. */ static void -adjust_simduid_builtins (hash_table <simduid_to_vf> &htab) +adjust_simduid_builtins (hash_table<simduid_to_vf> **htab) { basic_block bb; @@ -189,8 +189,8 @@ adjust_simduid_builtins (hash_table <simduid_to_vf> &htab) gcc_assert (TREE_CODE (arg) == SSA_NAME); simduid_to_vf *p = NULL, data; data.simduid = DECL_UID (SSA_NAME_VAR (arg)); - if (htab.is_created ()) - p = htab.find (&data); + if (*htab) + p = (*htab)->find (&data); if (p) vf = p->vf; switch (ifn) @@ -216,7 +216,7 @@ adjust_simduid_builtins (hash_table <simduid_to_vf> &htab) struct note_simd_array_uses_struct { - hash_table <simd_array_to_simduid> *htab; + hash_table<simd_array_to_simduid> **htab; unsigned int simduid; }; @@ -236,11 +236,11 @@ note_simd_array_uses_cb (tree *tp, int *walk_subtrees, void *data) && DECL_CONTEXT (*tp) == current_function_decl) { simd_array_to_simduid data; - if (!ns->htab->is_created ()) - ns->htab->create (15); + if (!*ns->htab) + *ns->htab = new hash_table<simd_array_to_simduid> (15); data.decl = *tp; data.simduid = ns->simduid; - simd_array_to_simduid **slot = ns->htab->find_slot (&data, INSERT); + simd_array_to_simduid **slot = (*ns->htab)->find_slot (&data, INSERT); if (*slot == NULL) { simd_array_to_simduid *p = XNEW (simd_array_to_simduid); @@ -258,7 +258,7 @@ note_simd_array_uses_cb (tree *tp, int *walk_subtrees, void *data) simduid. */ static void -note_simd_array_uses (hash_table <simd_array_to_simduid> *htab) +note_simd_array_uses (hash_table<simd_array_to_simduid> **htab) { basic_block bb; gimple_stmt_iterator gsi; @@ -389,8 +389,8 @@ vectorize_loops (void) unsigned int num_vectorized_loops = 0; unsigned int vect_loops_num; struct loop *loop; - hash_table <simduid_to_vf> simduid_to_vf_htab; - hash_table <simd_array_to_simduid> simd_array_to_simduid_htab; + hash_table<simduid_to_vf> *simduid_to_vf_htab = NULL; + hash_table<simd_array_to_simduid> *simd_array_to_simduid_htab = NULL; bool any_ifcvt_loops = false; unsigned ret = 0; @@ -400,7 +400,7 @@ vectorize_loops (void) if (vect_loops_num <= 1) { if (cfun->has_simduid_loops) - adjust_simduid_builtins (simduid_to_vf_htab); + adjust_simduid_builtins (&simduid_to_vf_htab); return 0; } @@ -484,11 +484,11 @@ vectorize_loops (void) if (loop->simduid) { simduid_to_vf *simduid_to_vf_data = XNEW (simduid_to_vf); - if (!simduid_to_vf_htab.is_created ()) - simduid_to_vf_htab.create (15); + if (!simduid_to_vf_htab) + simduid_to_vf_htab = new hash_table<simduid_to_vf> (15); simduid_to_vf_data->simduid = DECL_UID (loop->simduid); simduid_to_vf_data->vf = loop_vinfo->vectorization_factor; - *simduid_to_vf_htab.find_slot (simduid_to_vf_data, INSERT) + *simduid_to_vf_htab->find_slot (simduid_to_vf_data, INSERT) = simduid_to_vf_data; } @@ -541,24 +541,24 @@ vectorize_loops (void) /* Fold IFN_GOMP_SIMD_{VF,LANE,LAST_LANE} builtins. */ if (cfun->has_simduid_loops) - adjust_simduid_builtins (simduid_to_vf_htab); + adjust_simduid_builtins (&simduid_to_vf_htab); /* Shrink any "omp array simd" temporary arrays to the actual vectorization factors. */ - if (simd_array_to_simduid_htab.is_created ()) + if (simd_array_to_simduid_htab) { - for (hash_table <simd_array_to_simduid>::iterator iter - = simd_array_to_simduid_htab.begin (); - iter != simd_array_to_simduid_htab.end (); ++iter) + for (hash_table<simd_array_to_simduid>::iterator iter + = simd_array_to_simduid_htab->begin (); + iter != simd_array_to_simduid_htab->end (); ++iter) if ((*iter).simduid != -1U) { tree decl = (*iter).decl; int vf = 1; - if (simduid_to_vf_htab.is_created ()) + if (simduid_to_vf_htab) { simduid_to_vf *p = NULL, data; data.simduid = (*iter).simduid; - p = simduid_to_vf_htab.find (&data); + p = simduid_to_vf_htab->find (&data); if (p) vf = p->vf; } @@ -568,10 +568,10 @@ vectorize_loops (void) relayout_decl (decl); } - simd_array_to_simduid_htab.dispose (); + delete simd_array_to_simduid_htab; } - if (simduid_to_vf_htab.is_created ()) - simduid_to_vf_htab.dispose (); + delete simduid_to_vf_htab; + simduid_to_vf_htab = NULL; if (num_vectorized_loops > 0) { diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index c5cb037042f..9829ac8bcb7 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -332,7 +332,7 @@ typedef struct _loop_vec_info { vec<gimple> reduction_chains; /* Hash table used to choose the best peeling option. */ - hash_table <peel_info_hasher> peeling_htab; + hash_table<peel_info_hasher> *peeling_htab; /* Cost data used by the target cost model. */ void *target_cost_data; diff --git a/gcc/valtrack.c b/gcc/valtrack.c index 91cb0d51b30..b5c4913f54d 100644 --- a/gcc/valtrack.c +++ b/gcc/valtrack.c @@ -214,6 +214,7 @@ void dead_debug_global_init (struct dead_debug_global *debug, bitmap used) { debug->used = used; + debug->htab = NULL; if (used) bitmap_clear (used); } @@ -250,7 +251,7 @@ dead_debug_global_find (struct dead_debug_global *global, rtx reg) dead_debug_global_entry temp_entry; temp_entry.reg = reg; - dead_debug_global_entry *entry = global->htab.find (&temp_entry); + dead_debug_global_entry *entry = global->htab->find (&temp_entry); gcc_checking_assert (entry && entry->reg == temp_entry.reg); return entry; @@ -265,10 +266,11 @@ dead_debug_global_insert (struct dead_debug_global *global, rtx reg, rtx dtemp) temp_entry.reg = reg; temp_entry.dtemp = dtemp; - if (!global->htab.is_created ()) - global->htab.create (31); + if (!global->htab) + global->htab = new hash_table<dead_debug_hash_descr> (31); - dead_debug_global_entry **slot = global->htab.find_slot (&temp_entry, INSERT); + dead_debug_global_entry **slot = global->htab->find_slot (&temp_entry, + INSERT); gcc_checking_assert (!*slot); *slot = XNEW (dead_debug_global_entry); **slot = temp_entry; @@ -493,8 +495,8 @@ dead_debug_global_finish (struct dead_debug_global *global, bitmap used) if (global->used != used) BITMAP_FREE (global->used); - if (global->htab.is_created ()) - global->htab.dispose (); + delete global->htab; + global->htab = NULL; } /* Add USE to DEBUG, or substitute it right away if it's a pseudo in diff --git a/gcc/valtrack.h b/gcc/valtrack.h index 7ed9ae290e2..528eaad67bb 100644 --- a/gcc/valtrack.h +++ b/gcc/valtrack.h @@ -84,7 +84,7 @@ dead_debug_hash_descr::remove (value_type *p) struct dead_debug_global { /* This hash table that maps pseudos to debug temps. */ - hash_table <dead_debug_hash_descr> htab; + hash_table<dead_debug_hash_descr> *htab; /* For each entry in htab, the bit corresponding to its REGNO will be set. */ bitmap used; diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c index 9e71165e1c7..ece149250ff 100644 --- a/gcc/var-tracking.c +++ b/gcc/var-tracking.c @@ -501,7 +501,7 @@ variable_hasher::remove (value_type *var) variable_htab_free (var); } -typedef hash_table <variable_hasher> variable_table_type; +typedef hash_table<variable_hasher> variable_table_type; typedef variable_table_type::iterator variable_iterator_type; /* Structure for passing some other parameters to function @@ -515,7 +515,7 @@ typedef struct emit_note_data_def enum emit_note_where where; /* The variables and values active at this point. */ - variable_table_type vars; + variable_table_type *vars; } emit_note_data; /* Structure holding a refcounted hash table. If refcount > 1, @@ -526,7 +526,7 @@ typedef struct shared_hash_def int refcount; /* Actual hash table. */ - variable_table_type htab; + variable_table_type *htab; } *shared_hash; /* Structure holding the IN or OUT set for a basic block. */ @@ -589,7 +589,7 @@ static alloc_pool shared_hash_pool; static alloc_pool loc_exp_dep_pool; /* Changed variables, notes will be emitted for them. */ -static variable_table_type changed_variables; +static variable_table_type *changed_variables; /* Shall notes be emitted? */ static bool emit_notes; @@ -597,7 +597,7 @@ static bool emit_notes; /* Values whose dynamic location lists have gone empty, but whose cselib location lists are still usable. Use this to hold the current location, the backlinks, etc, during emit_notes. */ -static variable_table_type dropped_values; +static variable_table_type *dropped_values; /* Empty shared hashtable. */ static shared_hash empty_shared_hash; @@ -635,7 +635,7 @@ static void attrs_list_union (attrs *, attrs); static variable_def **unshare_variable (dataflow_set *set, variable_def **slot, variable var, enum var_init_status); -static void vars_copy (variable_table_type, variable_table_type); +static void vars_copy (variable_table_type *, variable_table_type *); static tree var_debug_decl (tree); static void var_reg_set (dataflow_set *, rtx, enum var_init_status, rtx); static void var_reg_delete_and_set (dataflow_set *, rtx, bool, @@ -652,7 +652,7 @@ static void dataflow_set_clear (dataflow_set *); static void dataflow_set_copy (dataflow_set *, dataflow_set *); static int variable_union_info_cmp_pos (const void *, const void *); static void dataflow_set_union (dataflow_set *, dataflow_set *); -static location_chain find_loc_in_1pdv (rtx, variable, variable_table_type); +static location_chain find_loc_in_1pdv (rtx, variable, variable_table_type *); static bool canon_value_cmp (rtx, rtx); static int loc_cmp (rtx, rtx); static bool variable_part_different_p (variable_part *, variable_part *); @@ -672,7 +672,7 @@ static bool vt_find_locations (void); static void dump_attrs_list (attrs); static void dump_var (variable); -static void dump_vars (variable_table_type); +static void dump_vars (variable_table_type *); static void dump_dataflow_set (dataflow_set *); static void dump_dataflow_sets (void); @@ -1582,7 +1582,7 @@ shared_hash_shared (shared_hash vars) /* Return the hash table for VARS. */ -static inline variable_table_type +static inline variable_table_type * shared_hash_htab (shared_hash vars) { return vars->htab; @@ -1606,7 +1606,7 @@ shared_hash_unshare (shared_hash vars) shared_hash new_vars = (shared_hash) pool_alloc (shared_hash_pool); gcc_assert (vars->refcount > 1); new_vars->refcount = 1; - new_vars->htab.create (vars->htab.elements () + 3); + new_vars->htab = new variable_table_type (vars->htab->elements () + 3); vars_copy (new_vars->htab, vars->htab); vars->refcount--; return new_vars; @@ -1630,7 +1630,7 @@ shared_hash_destroy (shared_hash vars) gcc_checking_assert (vars->refcount > 0); if (--vars->refcount == 0) { - vars->htab.dispose (); + delete vars->htab; pool_free (shared_hash_pool, vars); } } @@ -1644,7 +1644,7 @@ shared_hash_find_slot_unshare_1 (shared_hash *pvars, decl_or_value dv, { if (shared_hash_shared (*pvars)) *pvars = shared_hash_unshare (*pvars); - return shared_hash_htab (*pvars).find_slot_with_hash (dv, dvhash, ins); + return shared_hash_htab (*pvars)->find_slot_with_hash (dv, dvhash, ins); } static inline variable_def ** @@ -1661,9 +1661,9 @@ shared_hash_find_slot_unshare (shared_hash *pvars, decl_or_value dv, static inline variable_def ** shared_hash_find_slot_1 (shared_hash vars, decl_or_value dv, hashval_t dvhash) { - return shared_hash_htab (vars).find_slot_with_hash (dv, dvhash, - shared_hash_shared (vars) - ? NO_INSERT : INSERT); + return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash, + shared_hash_shared (vars) + ? NO_INSERT : INSERT); } static inline variable_def ** @@ -1678,7 +1678,7 @@ static inline variable_def ** shared_hash_find_slot_noinsert_1 (shared_hash vars, decl_or_value dv, hashval_t dvhash) { - return shared_hash_htab (vars).find_slot_with_hash (dv, dvhash, NO_INSERT); + return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash, NO_INSERT); } static inline variable_def ** @@ -1693,7 +1693,7 @@ shared_hash_find_slot_noinsert (shared_hash vars, decl_or_value dv) static inline variable shared_hash_find_1 (shared_hash vars, decl_or_value dv, hashval_t dvhash) { - return shared_hash_htab (vars).find_with_hash (dv, dvhash); + return shared_hash_htab (vars)->find_with_hash (dv, dvhash); } static inline variable @@ -1790,8 +1790,9 @@ unshare_variable (dataflow_set *set, variable_def **slot, variable var, if (var->in_changed_variables) { variable_def **cslot - = changed_variables.find_slot_with_hash (var->dv, - dv_htab_hash (var->dv), NO_INSERT); + = changed_variables->find_slot_with_hash (var->dv, + dv_htab_hash (var->dv), + NO_INSERT); gcc_assert (*cslot == (void *) var); var->in_changed_variables = false; variable_htab_free (var); @@ -1804,16 +1805,17 @@ unshare_variable (dataflow_set *set, variable_def **slot, variable var, /* Copy all variables from hash table SRC to hash table DST. */ static void -vars_copy (variable_table_type dst, variable_table_type src) +vars_copy (variable_table_type *dst, variable_table_type *src) { variable_iterator_type hi; variable var; - FOR_EACH_HASH_TABLE_ELEMENT (src, var, variable, hi) + FOR_EACH_HASH_TABLE_ELEMENT (*src, var, variable, hi) { variable_def **dstp; var->refcount++; - dstp = dst.find_slot_with_hash (var->dv, dv_htab_hash (var->dv), INSERT); + dstp = dst->find_slot_with_hash (var->dv, dv_htab_hash (var->dv), + INSERT); *dstp = var; } } @@ -2324,7 +2326,7 @@ clobber_overlapping_mems (dataflow_set *set, rtx loc) set->traversed_vars = set->vars; shared_hash_htab (set->vars) - .traverse <overlapping_mems*, drop_overlapping_mem_locs> (&coms); + ->traverse <overlapping_mems*, drop_overlapping_mem_locs> (&coms); set->traversed_vars = NULL; } @@ -3125,7 +3127,7 @@ dataflow_set_union (dataflow_set *dst, dataflow_set *src) variable_iterator_type hi; variable var; - FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (src->vars), + FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (src->vars), var, variable, hi) variable_union (var, dst); } @@ -3189,7 +3191,7 @@ dv_changed_p (decl_or_value dv) be in star-canonical form. */ static location_chain -find_loc_in_1pdv (rtx loc, variable var, variable_table_type vars) +find_loc_in_1pdv (rtx loc, variable var, variable_table_type *vars) { location_chain node; enum rtx_code loc_code; @@ -3246,7 +3248,7 @@ find_loc_in_1pdv (rtx loc, variable var, variable_table_type vars) gcc_checking_assert (!node->next); dv = dv_from_value (node->loc); - rvar = vars.find_with_hash (dv, dv_htab_hash (dv)); + rvar = vars->find_with_hash (dv, dv_htab_hash (dv)); return find_loc_in_1pdv (loc, rvar, vars); } @@ -4226,14 +4228,14 @@ dataflow_set_merge (dataflow_set *dst, dataflow_set *src2) variable_iterator_type hi; variable var; - src1_elems = shared_hash_htab (src1->vars).elements (); - src2_elems = shared_hash_htab (src2->vars).elements (); + src1_elems = shared_hash_htab (src1->vars)->elements (); + src2_elems = shared_hash_htab (src2->vars)->elements (); dataflow_set_init (dst); dst->stack_adjust = cur.stack_adjust; shared_hash_destroy (dst->vars); dst->vars = (shared_hash) pool_alloc (shared_hash_pool); dst->vars->refcount = 1; - dst->vars->htab.create (MAX (src1_elems, src2_elems)); + dst->vars->htab = new variable_table_type (MAX (src1_elems, src2_elems)); for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) attrs_list_mpdv_union (&dst->regs[i], src1->regs[i], src2->regs[i]); @@ -4243,10 +4245,10 @@ dataflow_set_merge (dataflow_set *dst, dataflow_set *src2) dsm.cur = src1; dsm.src_onepart_cnt = 0; - FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (dsm.src->vars), + FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.src->vars), var, variable, hi) variable_merge_over_src (var, &dsm); - FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (dsm.cur->vars), + FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.cur->vars), var, variable, hi) variable_merge_over_cur (var, &dsm); @@ -4593,14 +4595,14 @@ dataflow_post_merge_adjust (dataflow_set *set, dataflow_set **permp) dfpm.permp = permp; shared_hash_htab (set->vars) - .traverse <dfset_post_merge*, variable_post_merge_new_vals> (&dfpm); + ->traverse <dfset_post_merge*, variable_post_merge_new_vals> (&dfpm); if (*permp) shared_hash_htab ((*permp)->vars) - .traverse <dfset_post_merge*, variable_post_merge_perm_vals> (&dfpm); + ->traverse <dfset_post_merge*, variable_post_merge_perm_vals> (&dfpm); shared_hash_htab (set->vars) - .traverse <dataflow_set *, canonicalize_values_star> (set); + ->traverse <dataflow_set *, canonicalize_values_star> (set); shared_hash_htab (set->vars) - .traverse <dataflow_set *, canonicalize_vars_star> (set); + ->traverse <dataflow_set *, canonicalize_vars_star> (set); } /* Return a node whose loc is a MEM that refers to EXPR in the @@ -4608,7 +4610,7 @@ dataflow_post_merge_adjust (dataflow_set *set, dataflow_set **permp) any values recursively mentioned in the location lists. */ static location_chain -find_mem_expr_in_1pdv (tree expr, rtx val, variable_table_type vars) +find_mem_expr_in_1pdv (tree expr, rtx val, variable_table_type *vars) { location_chain node; decl_or_value dv; @@ -4622,7 +4624,7 @@ find_mem_expr_in_1pdv (tree expr, rtx val, variable_table_type vars) && !VALUE_RECURSED_INTO (val)); dv = dv_from_value (val); - var = vars.find_with_hash (dv, dv_htab_hash (dv)); + var = vars->find_with_hash (dv, dv_htab_hash (dv)); if (!var) return NULL; @@ -4873,10 +4875,10 @@ dataflow_set_clear_at_call (dataflow_set *set) { set->traversed_vars = set->vars; shared_hash_htab (set->vars) - .traverse <dataflow_set *, dataflow_set_preserve_mem_locs> (set); + ->traverse <dataflow_set *, dataflow_set_preserve_mem_locs> (set); set->traversed_vars = set->vars; shared_hash_htab (set->vars) - .traverse <dataflow_set *, dataflow_set_remove_mem_locs> (set); + ->traverse <dataflow_set *, dataflow_set_remove_mem_locs> (set); set->traversed_vars = NULL; } } @@ -4981,15 +4983,15 @@ dataflow_set_different (dataflow_set *old_set, dataflow_set *new_set) if (old_set->vars == new_set->vars) return false; - if (shared_hash_htab (old_set->vars).elements () - != shared_hash_htab (new_set->vars).elements ()) + if (shared_hash_htab (old_set->vars)->elements () + != shared_hash_htab (new_set->vars)->elements ()) return true; - FOR_EACH_HASH_TABLE_ELEMENT (shared_hash_htab (old_set->vars), + FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (old_set->vars), var1, variable, hi) { - variable_table_type htab = shared_hash_htab (new_set->vars); - variable var2 = htab.find_with_hash (var1->dv, dv_htab_hash (var1->dv)); + variable_table_type *htab = shared_hash_htab (new_set->vars); + variable var2 = htab->find_with_hash (var1->dv, dv_htab_hash (var1->dv)); if (!var2) { if (dump_file && (dump_flags & TDF_DETAILS)) @@ -6945,12 +6947,12 @@ compute_bb_dataflow (basic_block bb) dataflow_set_equiv_regs (out); shared_hash_htab (out->vars) - .traverse <dataflow_set *, canonicalize_values_mark> (out); + ->traverse <dataflow_set *, canonicalize_values_mark> (out); shared_hash_htab (out->vars) - .traverse <dataflow_set *, canonicalize_values_star> (out); + ->traverse <dataflow_set *, canonicalize_values_star> (out); #if ENABLE_CHECKING shared_hash_htab (out->vars) - .traverse <dataflow_set *, canonicalize_loc_order_check> (out); + ->traverse <dataflow_set *, canonicalize_loc_order_check> (out); #endif } changed = dataflow_set_different (&old_out, out); @@ -7022,10 +7024,11 @@ vt_find_locations (void) if (VTI (bb)->in.vars) { htabsz - -= shared_hash_htab (VTI (bb)->in.vars).size () - + shared_hash_htab (VTI (bb)->out.vars).size (); - oldinsz = shared_hash_htab (VTI (bb)->in.vars).elements (); - oldoutsz = shared_hash_htab (VTI (bb)->out.vars).elements (); + -= shared_hash_htab (VTI (bb)->in.vars)->size () + + shared_hash_htab (VTI (bb)->out.vars)->size (); + oldinsz = shared_hash_htab (VTI (bb)->in.vars)->elements (); + oldoutsz + = shared_hash_htab (VTI (bb)->out.vars)->elements (); } else oldinsz = oldoutsz = 0; @@ -7064,8 +7067,8 @@ vt_find_locations (void) /* Merge and merge_adjust should keep entries in canonical order. */ shared_hash_htab (in->vars) - .traverse <dataflow_set *, - canonicalize_loc_order_check> (in); + ->traverse <dataflow_set *, + canonicalize_loc_order_check> (in); #endif if (dst_can_be_shared) { @@ -7085,8 +7088,8 @@ vt_find_locations (void) } changed = compute_bb_dataflow (bb); - htabsz += shared_hash_htab (VTI (bb)->in.vars).size () - + shared_hash_htab (VTI (bb)->out.vars).size (); + htabsz += shared_hash_htab (VTI (bb)->in.vars)->size () + + shared_hash_htab (VTI (bb)->out.vars)->size (); if (htabmax && htabsz > htabmax) { @@ -7133,9 +7136,9 @@ vt_find_locations (void) fprintf (dump_file, "BB %i: in %i (was %i), out %i (was %i), rem %i + %i, tsz %i\n", bb->index, - (int)shared_hash_htab (VTI (bb)->in.vars).size (), + (int)shared_hash_htab (VTI (bb)->in.vars)->size (), oldinsz, - (int)shared_hash_htab (VTI (bb)->out.vars).size (), + (int)shared_hash_htab (VTI (bb)->out.vars)->size (), oldoutsz, (int)worklist->nodes, (int)pending->nodes, htabsz); @@ -7242,12 +7245,12 @@ dump_var (variable var) /* Print the information about variables from hash table VARS to dump file. */ static void -dump_vars (variable_table_type vars) +dump_vars (variable_table_type *vars) { - if (vars.elements () > 0) + if (vars->elements () > 0) { fprintf (dump_file, "Variables:\n"); - vars.traverse <void *, dump_var_tracking_slot> (NULL); + vars->traverse <void *, dump_var_tracking_slot> (NULL); } } @@ -7299,7 +7302,7 @@ variable_from_dropped (decl_or_value dv, enum insert_option insert) variable empty_var; onepart_enum_t onepart; - slot = dropped_values.find_slot_with_hash (dv, dv_htab_hash (dv), insert); + slot = dropped_values->find_slot_with_hash (dv, dv_htab_hash (dv), insert); if (!slot) return NULL; @@ -7370,7 +7373,7 @@ variable_was_changed (variable var, dataflow_set *set) /* Remember this decl or VALUE has been added to changed_variables. */ set_dv_changed (var->dv, true); - slot = changed_variables.find_slot_with_hash (var->dv, hash, INSERT); + slot = changed_variables->find_slot_with_hash (var->dv, hash, INSERT); if (*slot) { @@ -7397,9 +7400,9 @@ variable_was_changed (variable var, dataflow_set *set) if (onepart == ONEPART_VALUE || onepart == ONEPART_DEXPR) { - dslot = dropped_values.find_slot_with_hash (var->dv, - dv_htab_hash (var->dv), - INSERT); + dslot = dropped_values->find_slot_with_hash (var->dv, + dv_htab_hash (var->dv), + INSERT); empty_var = *dslot; if (empty_var) @@ -7464,7 +7467,7 @@ variable_was_changed (variable var, dataflow_set *set) if (shared_hash_shared (set->vars)) slot = shared_hash_find_slot_unshare (&set->vars, var->dv, NO_INSERT); - shared_hash_htab (set->vars).clear_slot (slot); + shared_hash_htab (set->vars)->clear_slot (slot); } } } @@ -7976,7 +7979,7 @@ delete_variable_part (dataflow_set *set, rtx loc, decl_or_value dv, struct expand_loc_callback_data { /* The variables and values active at this point. */ - variable_table_type vars; + variable_table_type *vars; /* Stack of values and debug_exprs under expansion, and their children. */ @@ -8065,7 +8068,7 @@ loc_exp_dep_clear (variable var) back-links in VARS. */ static void -loc_exp_insert_dep (variable var, rtx x, variable_table_type vars) +loc_exp_insert_dep (variable var, rtx x, variable_table_type *vars) { decl_or_value dv; variable xvar; @@ -8075,7 +8078,7 @@ loc_exp_insert_dep (variable var, rtx x, variable_table_type vars) /* ??? Build a vector of variables parallel to EXPANDING, to avoid an additional look up? */ - xvar = vars.find_with_hash (dv, dv_htab_hash (dv)); + xvar = vars->find_with_hash (dv, dv_htab_hash (dv)); if (!xvar) { @@ -8116,7 +8119,7 @@ loc_exp_insert_dep (variable var, rtx x, variable_table_type vars) static bool loc_exp_dep_set (variable var, rtx result, rtx *value, int count, - variable_table_type vars) + variable_table_type *vars) { bool pending_recursion = false; @@ -8145,7 +8148,7 @@ loc_exp_dep_set (variable var, rtx result, rtx *value, int count, attempt to compute a current location. */ static void -notify_dependents_of_resolved_value (variable ivar, variable_table_type vars) +notify_dependents_of_resolved_value (variable ivar, variable_table_type *vars) { loc_exp_dep *led, *next; @@ -8183,7 +8186,7 @@ notify_dependents_of_resolved_value (variable ivar, variable_table_type vars) continue; } - var = vars.find_with_hash (dv, dv_htab_hash (dv)); + var = vars->find_with_hash (dv, dv_htab_hash (dv)); if (!var) var = variable_from_dropped (dv, NO_INSERT); @@ -8427,7 +8430,7 @@ vt_expand_loc_callback (rtx x, bitmap regs, return NULL; } - var = elcd->vars.find_with_hash (dv, dv_htab_hash (dv)); + var = elcd->vars->find_with_hash (dv, dv_htab_hash (dv)); if (!var) { @@ -8534,7 +8537,7 @@ resolve_expansions_pending_recursion (vec<rtx, va_heap> *pending) equivalences in VARS, updating their CUR_LOCs in the process. */ static rtx -vt_expand_loc (rtx loc, variable_table_type vars) +vt_expand_loc (rtx loc, variable_table_type *vars) { struct expand_loc_callback_data data; rtx result; @@ -8556,7 +8559,7 @@ vt_expand_loc (rtx loc, variable_table_type vars) in VARS, updating their CUR_LOCs in the process. */ static rtx -vt_expand_1pvar (variable var, variable_table_type vars) +vt_expand_1pvar (variable var, variable_table_type *vars) { struct expand_loc_callback_data data; rtx loc; @@ -8587,7 +8590,7 @@ emit_note_insn_var_location (variable_def **varp, emit_note_data *data) variable var = *varp; rtx insn = data->insn; enum emit_note_where where = data->where; - variable_table_type vars = data->vars; + variable_table_type *vars = data->vars; rtx note, note_vl; int i, j, n_var_parts; bool complete; @@ -8802,7 +8805,7 @@ emit_note_insn_var_location (variable_def **varp, emit_note_data *data) set_dv_changed (var->dv, false); gcc_assert (var->in_changed_variables); var->in_changed_variables = false; - changed_variables.clear_slot (varp); + changed_variables->clear_slot (varp); /* Continue traversing the hash table. */ return 1; @@ -8834,11 +8837,11 @@ remove_value_from_changed_variables (rtx val) variable_def **slot; variable var; - slot = changed_variables.find_slot_with_hash (dv, dv_htab_hash (dv), + slot = changed_variables->find_slot_with_hash (dv, dv_htab_hash (dv), NO_INSERT); var = *slot; var->in_changed_variables = false; - changed_variables.clear_slot (slot); + changed_variables->clear_slot (slot); } /* If VAL (a value or debug_expr) has backlinks to variables actively @@ -8847,7 +8850,7 @@ remove_value_from_changed_variables (rtx val) have dependencies of their own to notify. */ static void -notify_dependents_of_changed_value (rtx val, variable_table_type htab, +notify_dependents_of_changed_value (rtx val, variable_table_type *htab, vec<rtx, va_heap> *changed_values_stack) { variable_def **slot; @@ -8855,13 +8858,13 @@ notify_dependents_of_changed_value (rtx val, variable_table_type htab, loc_exp_dep *led; decl_or_value dv = dv_from_rtx (val); - slot = changed_variables.find_slot_with_hash (dv, dv_htab_hash (dv), + slot = changed_variables->find_slot_with_hash (dv, dv_htab_hash (dv), NO_INSERT); if (!slot) - slot = htab.find_slot_with_hash (dv, dv_htab_hash (dv), NO_INSERT); + slot = htab->find_slot_with_hash (dv, dv_htab_hash (dv), NO_INSERT); if (!slot) - slot = dropped_values.find_slot_with_hash (dv, dv_htab_hash (dv), - NO_INSERT); + slot = dropped_values->find_slot_with_hash (dv, dv_htab_hash (dv), + NO_INSERT); var = *slot; while ((led = VAR_LOC_DEP_LST (var))) @@ -8892,14 +8895,14 @@ notify_dependents_of_changed_value (rtx val, variable_table_type htab, break; case ONEPART_VDECL: - ivar = htab.find_with_hash (ldv, dv_htab_hash (ldv)); + ivar = htab->find_with_hash (ldv, dv_htab_hash (ldv)); gcc_checking_assert (!VAR_LOC_DEP_LST (ivar)); variable_was_changed (ivar, NULL); break; case NOT_ONEPART: pool_free (loc_exp_dep_pool, led); - ivar = htab.find_with_hash (ldv, dv_htab_hash (ldv)); + ivar = htab->find_with_hash (ldv, dv_htab_hash (ldv)); if (ivar) { int i = ivar->n_var_parts; @@ -8929,7 +8932,7 @@ notify_dependents_of_changed_value (rtx val, variable_table_type htab, CHANGED_VARIABLES. */ static void -process_changed_values (variable_table_type htab) +process_changed_values (variable_table_type *htab) { int i, n; rtx val; @@ -8937,7 +8940,7 @@ process_changed_values (variable_table_type htab) /* Move values from changed_variables to changed_values_stack. */ changed_variables - .traverse <vec<rtx, va_heap>*, var_track_values_to_stack> + ->traverse <vec<rtx, va_heap>*, var_track_values_to_stack> (&changed_values_stack); /* Back-propagate change notifications in values while popping @@ -8969,9 +8972,9 @@ emit_notes_for_changes (rtx insn, enum emit_note_where where, shared_hash vars) { emit_note_data data; - variable_table_type htab = shared_hash_htab (vars); + variable_table_type *htab = shared_hash_htab (vars); - if (!changed_variables.elements ()) + if (!changed_variables->elements ()) return; if (MAY_HAVE_DEBUG_INSNS) @@ -8982,19 +8985,19 @@ emit_notes_for_changes (rtx insn, enum emit_note_where where, data.vars = htab; changed_variables - .traverse <emit_note_data*, emit_note_insn_var_location> (&data); + ->traverse <emit_note_data*, emit_note_insn_var_location> (&data); } /* Add variable *SLOT to the chain CHANGED_VARIABLES if it differs from the same variable in hash table DATA or is not there at all. */ int -emit_notes_for_differences_1 (variable_def **slot, variable_table_type new_vars) +emit_notes_for_differences_1 (variable_def **slot, variable_table_type *new_vars) { variable old_var, new_var; old_var = *slot; - new_var = new_vars.find_with_hash (old_var->dv, dv_htab_hash (old_var->dv)); + new_var = new_vars->find_with_hash (old_var->dv, dv_htab_hash (old_var->dv)); if (!new_var) { @@ -9061,12 +9064,12 @@ emit_notes_for_differences_1 (variable_def **slot, variable_table_type new_vars) table DATA. */ int -emit_notes_for_differences_2 (variable_def **slot, variable_table_type old_vars) +emit_notes_for_differences_2 (variable_def **slot, variable_table_type *old_vars) { variable old_var, new_var; new_var = *slot; - old_var = old_vars.find_with_hash (new_var->dv, dv_htab_hash (new_var->dv)); + old_var = old_vars->find_with_hash (new_var->dv, dv_htab_hash (new_var->dv)); if (!old_var) { int i; @@ -9087,10 +9090,10 @@ emit_notes_for_differences (rtx insn, dataflow_set *old_set, dataflow_set *new_set) { shared_hash_htab (old_set->vars) - .traverse <variable_table_type, emit_notes_for_differences_1> + ->traverse <variable_table_type *, emit_notes_for_differences_1> (shared_hash_htab (new_set->vars)); shared_hash_htab (new_set->vars) - .traverse <variable_table_type, emit_notes_for_differences_2> + ->traverse <variable_table_type *, emit_notes_for_differences_2> (shared_hash_htab (old_set->vars)); emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN, new_set->vars); } @@ -9446,7 +9449,7 @@ vt_emit_notes (void) basic_block bb; dataflow_set cur; - gcc_assert (!changed_variables.elements ()); + gcc_assert (!changed_variables->elements ()); /* Free memory occupied by the out hash tables, as they aren't used anymore. */ @@ -9459,7 +9462,7 @@ vt_emit_notes (void) if (MAY_HAVE_DEBUG_INSNS) { - dropped_values.create (cselib_get_next_uid () * 2); + dropped_values = new variable_table_type (cselib_get_next_uid () * 2); loc_exp_dep_pool = create_alloc_pool ("loc_exp_dep pool", sizeof (loc_exp_dep), 64); } @@ -9488,13 +9491,14 @@ vt_emit_notes (void) } #ifdef ENABLE_CHECKING shared_hash_htab (cur.vars) - .traverse <variable_table_type, emit_notes_for_differences_1> + ->traverse <variable_table_type *, emit_notes_for_differences_1> (shared_hash_htab (empty_shared_hash)); #endif dataflow_set_destroy (&cur); if (MAY_HAVE_DEBUG_INSNS) - dropped_values.dispose (); + delete dropped_values; + dropped_values = NULL; emit_notes = false; } @@ -9891,8 +9895,8 @@ vt_initialize (void) sizeof (struct shared_hash_def), 256); empty_shared_hash = (shared_hash) pool_alloc (shared_hash_pool); empty_shared_hash->refcount = 1; - empty_shared_hash->htab.create (1); - changed_variables.create (10); + empty_shared_hash->htab = new variable_table_type (1); + changed_variables = new variable_table_type (10); /* Init the IN and OUT sets. */ FOR_ALL_BB_FN (bb, cfun) @@ -10246,8 +10250,10 @@ vt_finalize (void) } } free_aux_for_blocks (); - empty_shared_hash->htab.dispose (); - changed_variables.dispose (); + delete empty_shared_hash->htab; + empty_shared_hash->htab = NULL; + delete changed_variables; + changed_variables = NULL; free_alloc_pool (attrs_pool); free_alloc_pool (var_pool); free_alloc_pool (loc_chain_pool); diff --git a/gcc/vtable-verify.c b/gcc/vtable-verify.c index b99ff6cf896..96586c4820a 100644 --- a/gcc/vtable-verify.c +++ b/gcc/vtable-verify.c @@ -182,11 +182,10 @@ vtbl_map_node_registration_find (struct vtbl_map_node *node, struct vtable_registration key; struct vtable_registration **slot; - gcc_assert (node && node->registered.is_created ()); + gcc_assert (node && node->registered); key.vtable_decl = vtable_decl; - slot = (struct vtable_registration **) node->registered.find_slot (&key, - NO_INSERT); + slot = node->registered->find_slot (&key, NO_INSERT); if (slot && (*slot)) { @@ -212,12 +211,11 @@ vtbl_map_node_registration_insert (struct vtbl_map_node *node, struct vtable_registration **slot; bool inserted_something = false; - if (!node || !node->registered.is_created ()) + if (!node || !node->registered) return false; key.vtable_decl = vtable_decl; - slot = (struct vtable_registration **) node->registered.find_slot (&key, - INSERT); + slot = node->registered->find_slot (&key, INSERT); if (! *slot) { @@ -307,11 +305,11 @@ vtbl_map_hasher::equal (const value_type *p1, const compare_type *p2) to find the nodes for various tasks (see comments in vtable-verify.h for more details. */ -typedef hash_table <vtbl_map_hasher> vtbl_map_table_type; +typedef hash_table<vtbl_map_hasher> vtbl_map_table_type; typedef vtbl_map_table_type::iterator vtbl_map_iterator_type; /* Vtable map variable nodes stored in a hash table. */ -static vtbl_map_table_type vtbl_map_hash; +static vtbl_map_table_type *vtbl_map_hash; /* Vtable map variable nodes stored in a vector. */ vec<struct vtbl_map_node *> vtbl_map_nodes_vec; @@ -328,7 +326,7 @@ vtbl_map_get_node (tree class_type) tree class_name; unsigned int type_quals; - if (!vtbl_map_hash.is_created ()) + if (!vtbl_map_hash) return NULL; gcc_assert (TREE_CODE (class_type) == RECORD_TYPE); @@ -346,8 +344,7 @@ vtbl_map_get_node (tree class_type) class_name = DECL_ASSEMBLER_NAME (class_type_decl); key.class_name = class_name; - slot = (struct vtbl_map_node **) vtbl_map_hash.find_slot (&key, - NO_INSERT); + slot = (struct vtbl_map_node **) vtbl_map_hash->find_slot (&key, NO_INSERT); if (!slot) return NULL; return *slot; @@ -365,8 +362,8 @@ find_or_create_vtbl_map_node (tree base_class_type) tree class_type_decl; unsigned int type_quals; - if (!vtbl_map_hash.is_created ()) - vtbl_map_hash.create (10); + if (!vtbl_map_hash) + vtbl_map_hash = new vtbl_map_table_type (10); /* Find the TYPE_DECL for the class. */ class_type_decl = TYPE_NAME (base_class_type); @@ -377,8 +374,7 @@ find_or_create_vtbl_map_node (tree base_class_type) gcc_assert (HAS_DECL_ASSEMBLER_NAME_P (class_type_decl)); key.class_name = DECL_ASSEMBLER_NAME (class_type_decl); - slot = (struct vtbl_map_node **) vtbl_map_hash.find_slot (&key, - INSERT); + slot = (struct vtbl_map_node **) vtbl_map_hash->find_slot (&key, INSERT); if (*slot) return *slot; @@ -396,7 +392,7 @@ find_or_create_vtbl_map_node (tree base_class_type) (node->class_info->parents).create (4); (node->class_info->children).create (4); - node->registered.create (16); + node->registered = new register_table_type (16); node->is_used = false; diff --git a/gcc/vtable-verify.h b/gcc/vtable-verify.h index 14735b1ca76..8ba04359841 100644 --- a/gcc/vtable-verify.h +++ b/gcc/vtable-verify.h @@ -64,7 +64,7 @@ struct registration_hasher : typed_noop_remove <struct vtable_registration> static inline bool equal (const value_type *, const compare_type *); }; -typedef hash_table <registration_hasher> register_table_type; +typedef hash_table<registration_hasher> register_table_type; typedef register_table_type::iterator registration_iterator_type; /* This struct is used to represent the class hierarchy information @@ -116,7 +116,7 @@ struct vtbl_map_node { variable. */ struct vtbl_map_node *next, *prev; /* Pointers for the linked list structure. */ - register_table_type registered; /* Hashtable of vtable pointers for which + register_table_type *registered; /* Hashtable of vtable pointers for which we have generated a _VLTRegisterPair call with this vtable map variable. */ bool is_used; /* Boolean indicating if we used this vtable map |