From 4a8fb1a1de7c34fc788ccca21f3a15980bbce093 Mon Sep 17 00:00:00 2001 From: Lawrence Crowl Date: Fri, 26 Apr 2013 00:28:35 +0000 Subject: This patch is the main part of a consolodation of the hash_table patches to the... This patch is the main part of a consolodation of the hash_table patches to the cxx-conversion branch for files not under gcc/config. Update various hash tables from htab_t to hash_table. Modify types and calls to match. * tree-parloops.c'reduction * tree-parloops.c'name_to_copy Fold reduction_info_hash and reduction_info_eq into new struct reduction_hasher. Fold name_to_copy_elt_eq and name_to_copy_elt_hash into new struct name_to_copy_hasher. * trans-mem.c'tm_log Fold tm_log_hash, tm_log_eq, tm_log_free into new struct log_entry_hasher. * trans-mem.c'tm_memopt_value_numbers Fold tm_memop_hash, tm_memop_eq into new struct tm_memop_hasher. * tree-ssa-strlen.c'decl_to_stridxlist_htab Fold decl_to_stridxlist_hash into new struct stridxlist_hasher. * tree-ssa-loop-ivopts.c'ivopts_data::inv_expr_tab Fold htab_inv_expr_hash and htab_inv_expr_eq into new struct iv_inv_expr_hasher. * tree-ssa-uncprop.c'equiv Equiv renamed to val_ssa_equiv because of name ambiguity with local variables. Fold equiv_hash, equiv_eq and equiv_free into new struct val_ssa_equiv_hasher. Renamed variables equiv_hash_elt to an_equiv_elt because of name ambiguity with struct type. Changed equiv_hash_elt_p to an_equiv_elt_p to match. * tree-ssa-phiopt.c'seen_ssa_names Fold name_to_bb_hash and name_to_bb_eq into new struct ssa_names_hasher. * tree-ssa-structalias.c'pointer_equiv_class_table * tree-ssa-structalias.c'location_equiv_class_table Fold equiv_class_label_hash and equiv_class_label_eq into new struct equiv_class_hasher. * tree-ssa-structalias.c'shared_bitmap_table Fold shared_bitmap_hash and shared_bitmap_eq into new struct shared_bitmap_hasher. * tree-ssa-live.c'var_map_base_init::tree_to_index New struct tree_int_map_hasher. * tree-sra.c'candidates Fold uid_decl_map_hash and uid_decl_map_eq into new struct uid_decl_hasher. This change moves the definitions from tree-ssa.c into tree-sra.c and removes the declarations from tree-flow.h tree-browser.c Remove stale declaration of removed TB_parent_eq. Fix template parameter for base class to match value_type. gimple.h Use gimplify_hasher::hash rather than gimple_tree_hash in the assertion check. Change return values to match return type. (I.e. no conversions.) * graphite-clast-to-gimple.c'ivs_params::newivs_index * graphite-clast-to-gimple.c'ivs_params::params_index * graphite-clast-to-gimple.c'print_generated_program::params_index * graphite-clast-to-gimple.c'gloog::newivs_index * graphite-clast-to-gimple.c'gloog::params_index * graphite.c graphite_transform_loops::bb_pbb_mapping * sese.c copy_bb_and_scalar_dependences::rename_map Move hash table declarations to a new graphite-htab.h, because they are used in few places. Remove unused: htab_t scop::original_pddrs SCOP_ORIGINAL_PDDRS Remove unused: insert_loop_close_phis insert_guard_phis debug_ivtype_map ivtype_map_elt_info new_ivtype_map_elt * gimplify.c'gimplify_ctx::temp_htab Move struct gimple_temp_hash_elt and struct gimplify_ctx to a new gimplify-ctx.h, because they are used few places. * cselib.c'cselib_hash_table * gcse.c'pre_ldst_table * gimple-ssa-strength-reduction.c'base_cand_map * haifa-sched.c'delay_htab * haifa-sched.c'delay_htab_i2 * ira-color.c'allocno_hard_regs_htab * ira-costs.c'cost_classes_htab * loop-invariant.c'merge_identical_invariants::eq * loop-iv.c'bivs * loop-unroll.c'opt_info::insns_to_split * loop-unroll.c'opt_info::insns_with_var_to_expand * passes.c'name_to_pass_map * plugin.c'event_tab * postreload-gcse.c'expr_table * store-motion.c'store_motion_mems_table * tree-cfg.c'discriminator_per_locus * tree-scalar-evolution.c'resolve_mixers::cache * tree-ssa-dom.c'avail_exprs Remove unused: dse.c bitmap clear_alias_sets dse.c bitmap disqualified_clear_alias_sets dse.c alloc_pool clear_alias_mode_pool dse.c dse_step2_spill dse.c dse_step5_spill graphds.h htab_t graph::indices * attribs.c'scoped_attributes::attribute_hash * bitmap.c'bitmap_desc_hash * dwarf2cfi.c'trace_index * dwarf2out.c'break_out_includes::cu_hash_table * dwarf2out.c'copy_decls_for_unworthy_types::decl_table * dwarf2out.c'optimize_external_refs::map * dwarf2out.c'output_comp_unit::extern_map * dwarf2out.c'output_comdat_type_unit::extern_map * dwarf2out.c'output_macinfo::macinfo_htab * dwarf2out.c'optimize_location_lists::htab * dwarf2out.c'dwarf2out_finish::comdat_type_table * except.c'ehspec_hash_type * except.c'assign_filter_values::ttypes * except.c'assign_filter_values::ehspec * except.c'sjlj_assign_call_site_values::ar_hash * except.c'convert_to_eh_region_ranges::ar_hash * trans-mem.c'tm_new_mem_hash * tree-browser.c'TB_up_ht * tree-eh.c'finally_tree Move the declaration of hash_table alloc_pool_hash in alloc-pool.c to after the method definitions for its parameter class. * ggc-common.c'loc_hash * ggc-common.c'ptr_hash Add a new hash_table method elements_with_deleted to meet the needs of gcc-common.c. Correct many methods with parameter types compare_type to the correct value_type. (Correct code was unlikely to notice the change, but incorrect code will.) * tree-complex.c'complex_variable_components * tree-parloops.c'eliminate_local_variables_stmt::decl_address * tree-parloops.c'separate_decls_in_region::decl_copies Move hash table declarations to a new tree-hasher.h, to resolve compilation dependences and because they are used in few places. * lto-streamer.h'output_block::string_hash_table * lto-streamer-in.c'file_name_hash_table * lto-streamer.c'tree_htab The struct string_slot moves from data-streamer.h to lto-streamer.h to resolve compilation dependences. Tested on x86_64. Index: gcc/ChangeLog 2013-04-25 Lawrence Crowl * Makefile.in: Update as needed below. * alloc-pool.c (static hash_table alloc_pool_hash): Move declaration to after the type's method definitons. * attribs.c (htab_t scoped_attributes::attribute_hash): Change type to hash_table. Update dependent calls and types. * bitmap.c (htab_t bitmap_desc_hash): Change type to hash_table. Update dependent calls and types. * cselib.c (htab_t cselib_hash_table): Change type to hash_table. Update dependent calls and types. * data-streamer.h (struct string_slot): Move to lto-streamer.h. (hash_string_slot_node): Move implementation into lto-streamer.h struct string_slot_hasher. (eq_string_slot_node): Likewise. * data-streamer-out.c: Update output_block::string_hash_table dependent calls and types. * dwarf2cfi.c (htab_t trace_index): Change type to hash_table. Update dependent calls and types. * dwarf2out.c (htab_t break_out_includes::cu_hash_table): Change type to hash_table. Update dependent calls and types. (htab_t copy_decls_for_unworthy_types::decl_table): Likewise. (htab_t optimize_external_refs::map): Likewise. (htab_t output_comp_unit::extern_map): Likewise. (htab_t output_comdat_type_unit::extern_map): Likewise. (htab_t output_macinfo::macinfo_htab): Likewise. (htab_t optimize_location_lists::htab): Likewise. (htab_t dwarf2out_finish::comdat_type_table): Likewise. * except.c (htab_t ehspec_hash_type): Change type to hash_table. Update dependent calls and types. (assign_filter_values::ttypes): Likewise. (assign_filter_values::ehspec): Likewise. (sjlj_assign_call_site_values::ar_hash): Likewise. (convert_to_eh_region_ranges::ar_hash): Likewise. * gcse.c (htab_t pre_ldst_table): Change type to hash_table. Update dependent calls and types. * ggc-common.c (htab_t saving_htab): Change type to hash_table. Update dependent calls and types. (htab_t loc_hash): Likewise. (htab_t ptr_hash): Likewise. (call_count): Rename ggc_call_count. (call_alloc): Rename ggc_call_alloc. (loc_descriptor): Rename make_loc_descriptor. (add_statistics): Rename ggc_add_statistics. * ggc-common.c (saving_htab): Change type to hash_table. Update dependent calls and types. * gimple.h (struct gimplify_ctx): Move to gimplify-ctx.h. (push_gimplify_context): Likewise. (pop_gimplify_context): Likewise. (struct gimple_temp_hash_elt): Added. (struct gimplify_hasher): Likewise. (struct gimplify_ctx.temp_htab): Change type to hash_table. Update dependent calls and types. * gimple-fold.c: Include gimplify-ctx.h. * gimple-ssa-strength-reduction.c (htab_t base_cand_map): Change type to hash_table. Update dependent calls and types. (base_cand_dump_callback): Rename to ssa_base_cand_dump_callback to avoid potential global name collision. * gimplify.c: Include gimplify-ctx.h. (struct gimple_temp_hash_elt): Move to gimplify-ctx.h. (htab_t gimplify_ctx::temp_htab): Update dependent calls and types for new type hash_table. (gimple_tree_hash): Move into gimplify_hasher in gimplify-ctx.h. (gimple_tree_eq): Move into gimplify_hasher in gimplify-ctx.h. * gimplify-ctx.h: New. (struct gimple_temp_hash_elt): Move from gimplify.c. (class gimplify_hasher): New. (struct gimplify_ctx): Move from gimple.h. (htab_t gimplify_ctx::temp_htab): Change type to hash_table. Update dependent calls and types. * graphite-clast-to-gimple.c: Include graphite-htab.h. (htab_t ivs_params::newivs_index): Change type to hash_table. Update dependent calls and types. (htab_t ivs_params::params_index): Likewise. (htab_t print_generated_program::params_index): Likewise. (htab_t gloog::newivs_index): Likewise. (htab_t gloog::params_index): Likewise. * graphite.c: Include graphite-htab.h. 4htab_t graphite_transform_loops::bb_pbb_mapping): Change type to hash_table. Update dependent calls and types. * graphite-clast-to-gimple.h: (extern gloog) Move to graphite-htab.h. (bb_pbb_map_hash): Fold into bb_pbb_htab_type in graphite-htab.h. (eq_bb_pbb_map): Fold into bb_pbb_htab_type in graphite-htab.h. * graphite-dependences.c: Include graphite-htab.h. (loop_is_parallel_p): Change hash table type of parameter. * graphite-htab.h: New. (typedef hash_table bb_pbb_htab_type): New. (extern find_pbb_via_hash): Move from graphite-poly.h. (extern loop_is_parallel_p): Move from graphite-poly.h. (extern get_loop_body_pbbs): Move from graphite-poly.h. * graphite-poly.h (extern find_pbb_via_hash): Move to graphite-htab.h. (extern loop_is_parallel_p): Move to graphite-htab.h. (extern get_loop_body_pbbs): Move to graphite-htab.h. * haifa-sched.c (htab_t delay_htab): Change type to hash_table. Update dependent calls and types. (htab_t delay_htab_i2): Likewise. * ira-color.c (htab_t allocno_hard_regs_htab): Change type to hash_table. Update dependent calls and types. * ira-costs.c (htab_t cost_classes_htab): Change type to hash_table. Update dependent calls and types. * loop-invariant.c (htab_t merge_identical_invariants::eq): Change type to hash_table. Update dependent calls and types. * loop-iv.c (htab_t bivs): Change type to hash_table. Update dependent calls and types. * loop-unroll.c (htab_t opt_info::insns_to_split): Change type to hash_table. Update dependent calls and types. (htab_t opt_info::insns_with_var_to_expand): Likewise. * lto-streamer.h (struct string_slot): Move from data-streamer.h (struct string_slot_hasher): New. (htab_t output_block::string_hash_table): Change type to hash_table. Update dependent calls and types. * lto-streamer-in.c (freeing_string_slot_hasher): New. (htab_t file_name_hash_table): Change type to hash_table. Update dependent calls and types. * lto-streamer-out.c: Update output_block::string_hash_table dependent calls and types. * lto-streamer.c (htab_t tree_htab): Change type to hash_table. Update dependent calls and types. * omp-low.c: Include gimplify-ctx.h. * passes.c (htab_t name_to_pass_map): Change type to hash_table. Update dependent calls and types. (pass_traverse): Rename to passes_pass_traverse. * plugin.c (htab_t event_tab): Change type to hash_table. Update dependent calls and types. * postreload-gcse.c (htab_t expr_table): Change type to hash_table. Update dependent calls and types. (dump_hash_table_entry): Rename dump_expr_hash_table_entry. * sese.c (debug_rename_map_1): Make extern. (htab_t copy_bb_and_scalar_dependences::rename_map): Change type to hash_table. Update dependent calls and types. * sese.h (extern debug_rename_map): Move to .c file. * store-motion.c (htab_t store_motion_mems_table): Change type to hash_table. Update dependent calls and types. * trans-mem.c (htab_t tm_new_mem_hash): Change type to hash_table. Update dependent calls and types. * tree-browser.c (htab_t TB_up_ht): Change type to hash_table. Update dependent calls and types. * tree-cfg.c (htab_t discriminator_per_locus): Change type to hash_table. Update dependent calls and types. * tree-complex.c: Include tree-hasher.h (htab_t complex_variable_components): Change type to hash_table. Update dependent calls and types. * tree-eh.c (htab_t finally_tree): Change type to hash_table. Update dependent calls and types. * tree-flow.h (extern int_tree_map_hash): Moved into tree-hasher struct int_tree_hasher. (extern int_tree_map_eq): Likewise. (uid_decl_map_hash): Removed. (extern decl_tree_map_eq): Likewise. * tree-hasher.h: New. (struct int_tree_hasher): New. (typedef int_tree_htab_type): New. * tree-inline.c: Include gimplify-ctx.h. * tree-mudflap.c: Include gimplify-ctx.h. * tree-parloops.c: Include tree-hasher.h. (htab_t eliminate_local_variables_stmt::decl_address): Change type to hash_table. Update dependent calls and types. (htab_t separate_decls_in_region::decl_copies): Likewise. * tree-scalar-evolution.c (htab_t resolve_mixers::cache): Change type to hash_table. Update dependent calls and types. * tree-sra.c (candidates): Change type to hash_table. Update dependent calls and types. * tree-ssa.c (int_tree_map_eq): Moved into struct int_tree_hasher in tree-flow.h. (int_tree_map_hash): Likewise. * tree-ssa-dom.c (htab_t avail_exprs): Change type to hash_table. Update dependent calls and types. * tree-ssa-live.c (var_map_base_init::tree_to_index): Change type to hash_table. Update dependent calls and types. * tree-ssa-loop-ivopts.c (struct ivopts_data.inv_expr_tab): Change type to hash_table. Update dependent calls and types. * tree-ssa-phiopt.c (seen_ssa_names): Change type to hash_table. Update dependent calls and types. * tree-ssa-strlen.c (decl_to_stridxlist_htab): Change type to hash_table. Update dependent calls and types. * tree-ssa-uncprop.c (equiv): Change type to hash_table. Update dependent calls and types. From-SVN: r198329 --- gcc/trans-mem.c | 197 +++++++++++++++++++++++++++++++++----------------------- 1 file changed, 117 insertions(+), 80 deletions(-) (limited to 'gcc/trans-mem.c') diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c index b0f18b5..5cb8286 100644 --- a/gcc/trans-mem.c +++ b/gcc/trans-mem.c @@ -20,6 +20,7 @@ #include "config.h" #include "system.h" #include "coretypes.h" +#include "hash-table.h" #include "tree.h" #include "gimple.h" #include "tree-flow.h" @@ -879,47 +880,29 @@ typedef struct tm_log_entry tree save_var; } *tm_log_entry_t; -/* The actual log. */ -static htab_t tm_log; - -/* Addresses to log with a save/restore sequence. These should be in - dominator order. */ -static vec tm_log_save_addresses; - -/* Map for an SSA_NAME originally pointing to a non aliased new piece - of memory (malloc, alloc, etc). */ -static htab_t tm_new_mem_hash; -enum thread_memory_type - { - mem_non_local = 0, - mem_thread_local, - mem_transaction_local, - mem_max - }; +/* Log entry hashtable helpers. */ -typedef struct tm_new_mem_map +struct log_entry_hasher { - /* SSA_NAME being dereferenced. */ - tree val; - enum thread_memory_type local_new_memory; -} tm_new_mem_map_t; + typedef tm_log_entry value_type; + typedef tm_log_entry compare_type; + static inline hashval_t hash (const value_type *); + static inline bool equal (const value_type *, const compare_type *); + static inline void remove (value_type *); +}; /* Htab support. Return hash value for a `tm_log_entry'. */ -static hashval_t -tm_log_hash (const void *p) +inline hashval_t +log_entry_hasher::hash (const value_type *log) { - const struct tm_log_entry *log = (const struct tm_log_entry *) p; return iterative_hash_expr (log->addr, 0); } /* Htab support. Return true if two log entries are the same. */ -static int -tm_log_eq (const void *p1, const void *p2) +inline bool +log_entry_hasher::equal (const value_type *log1, const compare_type *log2) { - const struct tm_log_entry *log1 = (const struct tm_log_entry *) p1; - const struct tm_log_entry *log2 = (const struct tm_log_entry *) p2; - /* FIXME: rth: I suggest that we get rid of the component refs etc. @@ -943,20 +926,68 @@ tm_log_eq (const void *p1, const void *p2) } /* Htab support. Free one tm_log_entry. */ -static void -tm_log_free (void *p) +inline void +log_entry_hasher::remove (value_type *lp) { - struct tm_log_entry *lp = (struct tm_log_entry *) p; lp->stmts.release (); free (lp); } + +/* The actual log. */ +static hash_table tm_log; + +/* Addresses to log with a save/restore sequence. These should be in + dominator order. */ +static vec tm_log_save_addresses; + +enum thread_memory_type + { + mem_non_local = 0, + mem_thread_local, + mem_transaction_local, + mem_max + }; + +typedef struct tm_new_mem_map +{ + /* SSA_NAME being dereferenced. */ + tree val; + enum thread_memory_type local_new_memory; +} tm_new_mem_map_t; + +/* Hashtable helpers. */ + +struct tm_mem_map_hasher : typed_free_remove +{ + typedef tm_new_mem_map_t value_type; + typedef tm_new_mem_map_t compare_type; + static inline hashval_t hash (const value_type *); + static inline bool equal (const value_type *, const compare_type *); +}; + +inline hashval_t +tm_mem_map_hasher::hash (const value_type *v) +{ + return (intptr_t)v->val >> 4; +} + +inline bool +tm_mem_map_hasher::equal (const value_type *v, const compare_type *c) +{ + return v->val == c->val; +} + +/* Map for an SSA_NAME originally pointing to a non aliased new piece + of memory (malloc, alloc, etc). */ +static hash_table tm_new_mem_hash; + /* Initialize logging data structures. */ static void tm_log_init (void) { - tm_log = htab_create (10, tm_log_hash, tm_log_eq, tm_log_free); - tm_new_mem_hash = htab_create (5, struct_ptr_hash, struct_ptr_eq, free); + tm_log.create (10); + tm_new_mem_hash.create (5); tm_log_save_addresses.create (5); } @@ -964,8 +995,8 @@ tm_log_init (void) static void tm_log_delete (void) { - htab_delete (tm_log); - htab_delete (tm_new_mem_hash); + tm_log.dispose (); + tm_new_mem_hash.dispose (); tm_log_save_addresses.release (); } @@ -1006,11 +1037,11 @@ transaction_invariant_address_p (const_tree mem, basic_block region_entry_block) static void tm_log_add (basic_block entry_block, tree addr, gimple stmt) { - void **slot; + tm_log_entry **slot; struct tm_log_entry l, *lp; l.addr = addr; - slot = htab_find_slot (tm_log, &l, INSERT); + slot = tm_log.find_slot (&l, INSERT); if (!*slot) { tree type = TREE_TYPE (addr); @@ -1051,7 +1082,7 @@ tm_log_add (basic_block entry_block, tree addr, gimple stmt) size_t i; gimple oldstmt; - lp = (struct tm_log_entry *) *slot; + lp = *slot; /* If we're generating a save/restore sequence, we don't care about statements. */ @@ -1153,10 +1184,10 @@ tm_log_emit_stmt (tree addr, gimple stmt) static void tm_log_emit (void) { - htab_iterator hi; + hash_table ::iterator hi; struct tm_log_entry *lp; - FOR_EACH_HTAB_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; @@ -1198,7 +1229,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 = (struct tm_log_entry *) *htab_find_slot (tm_log, &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. */ @@ -1234,7 +1265,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 = (struct tm_log_entry *) *htab_find_slot (tm_log, &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. */ @@ -1271,7 +1302,7 @@ thread_private_new_memory (basic_block entry_block, tree x) { gimple stmt = NULL; enum tree_code code; - void **slot; + tm_new_mem_map_t **slot; tm_new_mem_map_t elt, *elt_p; tree val = x; enum thread_memory_type retval = mem_transaction_local; @@ -1285,8 +1316,8 @@ thread_private_new_memory (basic_block entry_block, tree x) /* Look in cache first. */ elt.val = x; - slot = htab_find_slot (tm_new_mem_hash, &elt, INSERT); - elt_p = (tm_new_mem_map_t *) *slot; + slot = tm_new_mem_hash.find_slot (&elt, INSERT); + elt_p = *slot; if (elt_p) return elt_p->local_new_memory; @@ -3146,6 +3177,35 @@ typedef struct tm_memop tree addr; } *tm_memop_t; +/* TM memory operation hashtable helpers. */ + +struct tm_memop_hasher : typed_free_remove +{ + typedef tm_memop value_type; + typedef tm_memop compare_type; + static inline hashval_t hash (const value_type *); + static inline bool equal (const value_type *, const compare_type *); +}; + +/* Htab support. Return a hash value for a `tm_memop'. */ +inline hashval_t +tm_memop_hasher::hash (const value_type *mem) +{ + tree addr = mem->addr; + /* We drill down to the SSA_NAME/DECL for the hash, but equality is + actually done with operand_equal_p (see tm_memop_eq). */ + if (TREE_CODE (addr) == ADDR_EXPR) + addr = TREE_OPERAND (addr, 0); + return iterative_hash_expr (addr, 0); +} + +/* Htab support. Return true if two tm_memop's are the same. */ +inline bool +tm_memop_hasher::equal (const value_type *mem1, const compare_type *mem2) +{ + return operand_equal_p (mem1->addr, mem2->addr, 0); +} + /* Sets for solving data flow equations in the memory optimization pass. */ struct tm_memopt_bitmaps { @@ -3178,7 +3238,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 htab_t tm_memopt_value_numbers; +static hash_table tm_memopt_value_numbers; #define STORE_AVAIL_IN(BB) \ ((struct tm_memopt_bitmaps *) ((BB)->aux))->store_avail_in @@ -3201,29 +3261,6 @@ static htab_t tm_memopt_value_numbers; #define BB_VISITED_P(BB) \ ((struct tm_memopt_bitmaps *) ((BB)->aux))->visited_p -/* Htab support. Return a hash value for a `tm_memop'. */ -static hashval_t -tm_memop_hash (const void *p) -{ - const struct tm_memop *mem = (const struct tm_memop *) p; - tree addr = mem->addr; - /* We drill down to the SSA_NAME/DECL for the hash, but equality is - actually done with operand_equal_p (see tm_memop_eq). */ - if (TREE_CODE (addr) == ADDR_EXPR) - addr = TREE_OPERAND (addr, 0); - return iterative_hash_expr (addr, 0); -} - -/* Htab support. Return true if two tm_memop's are the same. */ -static int -tm_memop_eq (const void *p1, const void *p2) -{ - const struct tm_memop *mem1 = (const struct tm_memop *) p1; - const struct tm_memop *mem2 = (const struct tm_memop *) p2; - - return operand_equal_p (mem1->addr, mem2->addr, 0); -} - /* Given a TM load/store in STMT, return the value number for the address it accesses. */ @@ -3231,13 +3268,13 @@ static unsigned int tm_memopt_value_number (gimple stmt, enum insert_option op) { struct tm_memop tmpmem, *mem; - void **slot; + tm_memop **slot; gcc_assert (is_tm_load (stmt) || is_tm_store (stmt)); tmpmem.addr = gimple_call_arg (stmt, 0); - slot = htab_find_slot (tm_memopt_value_numbers, &tmpmem, op); + slot = tm_memopt_value_numbers.find_slot (&tmpmem, op); if (*slot) - mem = (struct tm_memop *) *slot; + mem = *slot; else if (op == INSERT) { mem = XNEW (struct tm_memop); @@ -3295,11 +3332,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) { - htab_iterator hi; - struct tm_memop *mem; + hash_table ::iterator hi; + struct tm_memop *mem = NULL; /* Yeah, yeah, yeah. Whatever. This is just for debugging. */ - FOR_EACH_HTAB_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); @@ -3734,7 +3771,7 @@ execute_tm_memopt (void) vec bbs; tm_memopt_value_id = 0; - tm_memopt_value_numbers = htab_create (10, tm_memop_hash, tm_memop_eq, free); + tm_memopt_value_numbers.create (10); for (region = all_tm_regions; region; region = region->next) { @@ -3768,10 +3805,10 @@ execute_tm_memopt (void) tm_memopt_free_sets (bbs); bbs.release (); bitmap_obstack_release (&tm_memopt_obstack); - htab_empty (tm_memopt_value_numbers); + tm_memopt_value_numbers.empty (); } - htab_delete (tm_memopt_value_numbers); + tm_memopt_value_numbers.dispose (); return 0; } -- cgit v1.1